1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/test_tools/quic_dispatcher_peer.h"
6
7 #include "quiche/quic/core/quic_dispatcher.h"
8 #include "quiche/quic/core/quic_packet_writer_wrapper.h"
9
10 namespace quic {
11 namespace test {
12
13 // static
GetTimeWaitListManager(QuicDispatcher * dispatcher)14 QuicTimeWaitListManager* QuicDispatcherPeer::GetTimeWaitListManager(
15 QuicDispatcher* dispatcher) {
16 return dispatcher->time_wait_list_manager_.get();
17 }
18
19 // static
SetTimeWaitListManager(QuicDispatcher * dispatcher,QuicTimeWaitListManager * time_wait_list_manager)20 void QuicDispatcherPeer::SetTimeWaitListManager(
21 QuicDispatcher* dispatcher,
22 QuicTimeWaitListManager* time_wait_list_manager) {
23 dispatcher->time_wait_list_manager_.reset(time_wait_list_manager);
24 }
25
26 // static
UseWriter(QuicDispatcher * dispatcher,QuicPacketWriterWrapper * writer)27 void QuicDispatcherPeer::UseWriter(QuicDispatcher* dispatcher,
28 QuicPacketWriterWrapper* writer) {
29 writer->set_writer(dispatcher->writer_.release());
30 dispatcher->writer_.reset(writer);
31 }
32
33 // static
GetWriter(QuicDispatcher * dispatcher)34 QuicPacketWriter* QuicDispatcherPeer::GetWriter(QuicDispatcher* dispatcher) {
35 return dispatcher->writer_.get();
36 }
37
38 // static
GetCache(QuicDispatcher * dispatcher)39 QuicCompressedCertsCache* QuicDispatcherPeer::GetCache(
40 QuicDispatcher* dispatcher) {
41 return dispatcher->compressed_certs_cache();
42 }
43
44 // static
GetHelper(QuicDispatcher * dispatcher)45 QuicConnectionHelperInterface* QuicDispatcherPeer::GetHelper(
46 QuicDispatcher* dispatcher) {
47 return dispatcher->helper_.get();
48 }
49
50 // static
GetAlarmFactory(QuicDispatcher * dispatcher)51 QuicAlarmFactory* QuicDispatcherPeer::GetAlarmFactory(
52 QuicDispatcher* dispatcher) {
53 return dispatcher->alarm_factory_.get();
54 }
55
56 // static
GetWriteBlockedList(QuicDispatcher * dispatcher)57 QuicDispatcher::WriteBlockedList* QuicDispatcherPeer::GetWriteBlockedList(
58 QuicDispatcher* dispatcher) {
59 return &dispatcher->write_blocked_list_;
60 }
61
62 // static
GetAndClearLastError(QuicDispatcher * dispatcher)63 QuicErrorCode QuicDispatcherPeer::GetAndClearLastError(
64 QuicDispatcher* dispatcher) {
65 QuicErrorCode ret = dispatcher->last_error_;
66 dispatcher->last_error_ = QUIC_NO_ERROR;
67 return ret;
68 }
69
70 // static
GetBufferedPackets(QuicDispatcher * dispatcher)71 QuicBufferedPacketStore* QuicDispatcherPeer::GetBufferedPackets(
72 QuicDispatcher* dispatcher) {
73 return &(dispatcher->buffered_packets_);
74 }
75
76 // static
set_new_sessions_allowed_per_event_loop(QuicDispatcher * dispatcher,size_t num_session_allowed)77 void QuicDispatcherPeer::set_new_sessions_allowed_per_event_loop(
78 QuicDispatcher* dispatcher, size_t num_session_allowed) {
79 dispatcher->new_sessions_allowed_per_event_loop_ = num_session_allowed;
80 }
81
82 // static
SendPublicReset(QuicDispatcher * dispatcher,const QuicSocketAddress & self_address,const QuicSocketAddress & peer_address,QuicConnectionId connection_id,bool ietf_quic,size_t received_packet_length,std::unique_ptr<QuicPerPacketContext> packet_context)83 void QuicDispatcherPeer::SendPublicReset(
84 QuicDispatcher* dispatcher, const QuicSocketAddress& self_address,
85 const QuicSocketAddress& peer_address, QuicConnectionId connection_id,
86 bool ietf_quic, size_t received_packet_length,
87 std::unique_ptr<QuicPerPacketContext> packet_context) {
88 dispatcher->time_wait_list_manager()->SendPublicReset(
89 self_address, peer_address, connection_id, ietf_quic,
90 received_packet_length, std::move(packet_context));
91 }
92
93 // static
GetPerPacketContext(QuicDispatcher * dispatcher)94 std::unique_ptr<QuicPerPacketContext> QuicDispatcherPeer::GetPerPacketContext(
95 QuicDispatcher* dispatcher) {
96 return dispatcher->GetPerPacketContext();
97 }
98
99 // static
RestorePerPacketContext(QuicDispatcher * dispatcher,std::unique_ptr<QuicPerPacketContext> context)100 void QuicDispatcherPeer::RestorePerPacketContext(
101 QuicDispatcher* dispatcher, std::unique_ptr<QuicPerPacketContext> context) {
102 dispatcher->RestorePerPacketContext(std::move(context));
103 }
104
105 // static
SelectAlpn(QuicDispatcher * dispatcher,const std::vector<std::string> & alpns)106 std::string QuicDispatcherPeer::SelectAlpn(
107 QuicDispatcher* dispatcher, const std::vector<std::string>& alpns) {
108 return dispatcher->SelectAlpn(alpns);
109 }
110
111 // static
GetFirstSessionIfAny(QuicDispatcher * dispatcher)112 QuicSession* QuicDispatcherPeer::GetFirstSessionIfAny(
113 QuicDispatcher* dispatcher) {
114 if (dispatcher->reference_counted_session_map_.empty()) {
115 return nullptr;
116 }
117 return dispatcher->reference_counted_session_map_.begin()->second.get();
118 }
119
120 // static
FindSession(const QuicDispatcher * dispatcher,QuicConnectionId id)121 const QuicSession* QuicDispatcherPeer::FindSession(
122 const QuicDispatcher* dispatcher, QuicConnectionId id) {
123 auto it = dispatcher->reference_counted_session_map_.find(id);
124 return (it == dispatcher->reference_counted_session_map_.end())
125 ? nullptr
126 : it->second.get();
127 }
128
129 // static
GetClearResetAddressesAlarm(QuicDispatcher * dispatcher)130 QuicAlarm* QuicDispatcherPeer::GetClearResetAddressesAlarm(
131 QuicDispatcher* dispatcher) {
132 return dispatcher->clear_stateless_reset_addresses_alarm_.get();
133 }
134
135 } // namespace test
136 } // namespace quic
137