1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
#define NET_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
#include "base/basictypes.h"
#include "net/base/ip_endpoint.h"
#include "net/quic/quic_connection_stats.h"
#include "net/quic/quic_protocol.h"
namespace net {
struct QuicAckFrame;
struct QuicPacketHeader;
class QuicAlarm;
class QuicConnection;
class QuicConnectionHelperInterface;
class QuicConnectionVisitorInterface;
class QuicEncryptedPacket;
class QuicFecGroup;
class QuicFramer;
class QuicPacketCreator;
class QuicPacketWriter;
class QuicReceivedPacketManager;
class QuicSentPacketManager;
class ReceiveAlgorithmInterface;
class SendAlgorithmInterface;
namespace test {
// Peer to make public a number of otherwise private QuicConnection methods.
class QuicConnectionPeer {
public:
static void SendAck(QuicConnection* connection);
static void SetReceiveAlgorithm(QuicConnection* connection,
ReceiveAlgorithmInterface* receive_algorithm);
static void SetSendAlgorithm(QuicConnection* connection,
SendAlgorithmInterface* send_algorithm);
static QuicAckFrame* CreateAckFrame(QuicConnection* connection);
static QuicConnectionVisitorInterface* GetVisitor(
QuicConnection* connection);
static QuicPacketCreator* GetPacketCreator(QuicConnection* connection);
static QuicSentPacketManager* GetSentPacketManager(
QuicConnection* connection);
static QuicReceivedPacketManager* GetReceivedPacketManager(
QuicConnection* connection);
static QuicTime::Delta GetNetworkTimeout(QuicConnection* connection);
static bool IsSavedForRetransmission(
QuicConnection* connection,
QuicPacketSequenceNumber sequence_number);
static bool IsRetransmission(QuicConnection* connection,
QuicPacketSequenceNumber sequence_number);
static QuicPacketEntropyHash GetSentEntropyHash(
QuicConnection* connection,
QuicPacketSequenceNumber sequence_number);
static bool IsValidEntropy(QuicConnection* connection,
QuicPacketSequenceNumber largest_observed,
const SequenceNumberSet& missing_packets,
QuicPacketEntropyHash entropy_hash);
static QuicPacketEntropyHash ReceivedEntropyHash(
QuicConnection* connection,
QuicPacketSequenceNumber sequence_number);
static bool IsServer(QuicConnection* connection);
static void SetIsServer(QuicConnection* connection, bool is_server);
static void SetSelfAddress(QuicConnection* connection,
const IPEndPoint& self_address);
static void SetPeerAddress(QuicConnection* connection,
const IPEndPoint& peer_address);
static void SwapCrypters(QuicConnection* connection, QuicFramer* framer);
static QuicConnectionHelperInterface* GetHelper(QuicConnection* connection);
static QuicFramer* GetFramer(QuicConnection* connection);
// Set last_header_->fec_group = fec_group and return connection->GetFecGroup
static QuicFecGroup* GetFecGroup(QuicConnection* connection, int fec_group);
static QuicAlarm* GetAckAlarm(QuicConnection* connection);
static QuicAlarm* GetRetransmissionAlarm(QuicConnection* connection);
static QuicAlarm* GetSendAlarm(QuicConnection* connection);
static QuicAlarm* GetResumeWritesAlarm(QuicConnection* connection);
static QuicAlarm* GetTimeoutAlarm(QuicConnection* connection);
static QuicPacketWriter* GetWriter(QuicConnection* connection);
static void SetWriter(QuicConnection* connection, QuicPacketWriter* writer);
static void CloseConnection(QuicConnection* connection);
static QuicEncryptedPacket* GetConnectionClosePacket(
QuicConnection* connection);
private:
DISALLOW_COPY_AND_ASSIGN(QuicConnectionPeer);
};
} // namespace test
} // namespace net
#endif // NET_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
|
