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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// 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 REMOTING_PROTOCOL_CONNECTION_TESTER_H_
#define REMOTING_PROTOCOL_CONNECTION_TESTER_H_
#include <list>
#include <memory>
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "remoting/protocol/message_pipe.h"
namespace net {
class DrainableIOBuffer;
class GrowableIOBuffer;
class IOBuffer;
} // namespace net
namespace remoting {
class CompoundBuffer;
class VideoPacket;
namespace protocol {
class P2PDatagramSocket;
class P2PStreamSocket;
// This class is used by unit tests to verify that a connection
// between two sockets works properly, i.e. data is delivered from one
// end to the other.
class StreamConnectionTester {
public:
StreamConnectionTester(P2PStreamSocket* client_socket,
P2PStreamSocket* host_socket,
int message_size,
int message_count);
~StreamConnectionTester();
void Start();
bool done() { return done_; }
void CheckResults();
protected:
void Done();
void InitBuffers();
void DoWrite();
void OnWritten(int result);
void HandleWriteResult(int result);
void DoRead();
void OnRead(int result);
void HandleReadResult(int result);
private:
const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
P2PStreamSocket* host_socket_;
P2PStreamSocket* client_socket_;
int message_size_;
int test_data_size_;
bool done_;
scoped_refptr<net::DrainableIOBuffer> output_buffer_;
scoped_refptr<net::GrowableIOBuffer> input_buffer_;
int write_errors_;
int read_errors_;
};
class DatagramConnectionTester {
public:
DatagramConnectionTester(P2PDatagramSocket* client_socket,
P2PDatagramSocket* host_socket,
int message_size,
int message_count,
int delay_ms);
~DatagramConnectionTester() ;
void Start();
void CheckResults();
private:
void Done();
void DoWrite();
void OnWritten(int result);
void HandleWriteResult(int result);
void DoRead();
void OnRead(int result);
void HandleReadResult(int result);
const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
P2PDatagramSocket* host_socket_;
P2PDatagramSocket* client_socket_;
int message_size_;
int message_count_;
int delay_ms_;
bool done_;
std::vector<scoped_refptr<net::IOBuffer> > sent_packets_;
scoped_refptr<net::IOBuffer> read_buffer_;
int write_errors_;
int read_errors_;
int packets_sent_;
int packets_received_;
int bad_packets_received_;
};
class MessagePipeConnectionTester : public MessagePipe::EventHandler {
public:
MessagePipeConnectionTester(MessagePipe* client_pipe,
MessagePipe* host_pipe,
int message_size,
int message_count);
~MessagePipeConnectionTester() override;
void RunAndCheckResults();
protected:
// MessagePipe::EventHandler interface.
void OnMessagePipeOpen() override;
void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override;
void OnMessagePipeClosed() override;
private:
base::RunLoop run_loop_;
MessagePipe* host_pipe_;
MessagePipe* client_pipe_;
int message_size_;
int message_count_;
std::vector<std::unique_ptr<VideoPacket>> sent_messages_;
std::vector<std::unique_ptr<VideoPacket>> received_messages_;
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_CONNECTION_TESTER_H_
|
