OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/protocol/pseudotcp_adapter.h" | 5 #include "remoting/protocol/pseudotcp_adapter.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
11 #include "base/compiler_specific.h" | 11 #include "base/compiler_specific.h" |
12 #include "jingle/glue/thread_wrapper.h" | 12 #include "jingle/glue/thread_wrapper.h" |
13 #include "net/base/io_buffer.h" | 13 #include "net/base/io_buffer.h" |
14 #include "net/base/net_errors.h" | 14 #include "net/base/net_errors.h" |
15 #include "net/base/test_completion_callback.h" | 15 #include "net/base/test_completion_callback.h" |
| 16 #include "remoting/protocol/p2p_datagram_socket.h" |
| 17 #include "remoting/protocol/p2p_stream_socket.h" |
16 #include "testing/gmock/include/gmock/gmock.h" | 18 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
18 | 20 |
19 namespace remoting { | 21 namespace remoting { |
20 namespace protocol { | 22 namespace protocol { |
21 | 23 |
22 namespace { | 24 namespace { |
23 | 25 |
24 const int kMessageSize = 1024; | 26 const int kMessageSize = 1024; |
25 const int kMessages = 100; | 27 const int kMessages = 100; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
58 return false; | 60 return false; |
59 } | 61 } |
60 | 62 |
61 private: | 63 private: |
62 double volume_; | 64 double volume_; |
63 double rate_; | 65 double rate_; |
64 double level_; | 66 double level_; |
65 base::TimeTicks last_update_; | 67 base::TimeTicks last_update_; |
66 }; | 68 }; |
67 | 69 |
68 class FakeSocket : public net::Socket { | 70 class FakeSocket : public P2PDatagramSocket { |
69 public: | 71 public: |
70 FakeSocket() | 72 FakeSocket() |
71 : rate_limiter_(NULL), | 73 : rate_limiter_(NULL), |
72 latency_ms_(0) { | 74 latency_ms_(0) { |
73 } | 75 } |
74 ~FakeSocket() override {} | 76 ~FakeSocket() override {} |
75 | 77 |
76 void AppendInputPacket(const std::vector<char>& data) { | 78 void AppendInputPacket(const std::vector<char>& data) { |
77 if (rate_limiter_ && rate_limiter_->DropNextPacket()) | 79 if (rate_limiter_ && rate_limiter_->DropNextPacket()) |
78 return; // Lose the packet. | 80 return; // Lose the packet. |
(...skipping 13 matching lines...) Expand all Loading... |
92 void Connect(FakeSocket* peer_socket) { | 94 void Connect(FakeSocket* peer_socket) { |
93 peer_socket_ = peer_socket; | 95 peer_socket_ = peer_socket; |
94 } | 96 } |
95 | 97 |
96 void set_rate_limiter(RateLimiter* rate_limiter) { | 98 void set_rate_limiter(RateLimiter* rate_limiter) { |
97 rate_limiter_ = rate_limiter; | 99 rate_limiter_ = rate_limiter; |
98 }; | 100 }; |
99 | 101 |
100 void set_latency(int latency_ms) { latency_ms_ = latency_ms; }; | 102 void set_latency(int latency_ms) { latency_ms_ = latency_ms; }; |
101 | 103 |
102 // net::Socket interface. | 104 // P2PDatagramSocket interface. |
103 int Read(net::IOBuffer* buf, | 105 int Recv(const scoped_refptr<net::IOBuffer>& buf, int buf_len, |
104 int buf_len, | |
105 const net::CompletionCallback& callback) override { | 106 const net::CompletionCallback& callback) override { |
106 CHECK(read_callback_.is_null()); | 107 CHECK(read_callback_.is_null()); |
107 CHECK(buf); | 108 CHECK(buf); |
108 | 109 |
109 if (incoming_packets_.size() > 0) { | 110 if (incoming_packets_.size() > 0) { |
110 scoped_refptr<net::IOBuffer> buffer(buf); | 111 scoped_refptr<net::IOBuffer> buffer(buf); |
111 int size = std::min( | 112 int size = std::min( |
112 static_cast<int>(incoming_packets_.front().size()), buf_len); | 113 static_cast<int>(incoming_packets_.front().size()), buf_len); |
113 memcpy(buffer->data(), &*incoming_packets_.front().begin(), size); | 114 memcpy(buffer->data(), &*incoming_packets_.front().begin(), size); |
114 incoming_packets_.pop_front(); | 115 incoming_packets_.pop_front(); |
115 return size; | 116 return size; |
116 } else { | 117 } else { |
117 read_callback_ = callback; | 118 read_callback_ = callback; |
118 read_buffer_ = buf; | 119 read_buffer_ = buf; |
119 read_buffer_size_ = buf_len; | 120 read_buffer_size_ = buf_len; |
120 return net::ERR_IO_PENDING; | 121 return net::ERR_IO_PENDING; |
121 } | 122 } |
122 } | 123 } |
123 | 124 |
124 int Write(net::IOBuffer* buf, | 125 int Send(const scoped_refptr<net::IOBuffer>& buf, int buf_len, |
125 int buf_len, | 126 const net::CompletionCallback& callback) override { |
126 const net::CompletionCallback& callback) override { | |
127 DCHECK(buf); | 127 DCHECK(buf); |
128 if (peer_socket_) { | 128 if (peer_socket_) { |
129 base::MessageLoop::current()->PostDelayedTask( | 129 base::MessageLoop::current()->PostDelayedTask( |
130 FROM_HERE, | 130 FROM_HERE, |
131 base::Bind(&FakeSocket::AppendInputPacket, | 131 base::Bind(&FakeSocket::AppendInputPacket, |
132 base::Unretained(peer_socket_), | 132 base::Unretained(peer_socket_), |
133 std::vector<char>(buf->data(), buf->data() + buf_len)), | 133 std::vector<char>(buf->data(), buf->data() + buf_len)), |
134 base::TimeDelta::FromMilliseconds(latency_ms_)); | 134 base::TimeDelta::FromMilliseconds(latency_ms_)); |
135 } | 135 } |
136 | 136 |
137 return buf_len; | 137 return buf_len; |
138 } | 138 } |
139 | 139 |
140 int SetReceiveBufferSize(int32 size) override { | |
141 NOTIMPLEMENTED(); | |
142 return net::ERR_NOT_IMPLEMENTED; | |
143 } | |
144 int SetSendBufferSize(int32 size) override { | |
145 NOTIMPLEMENTED(); | |
146 return net::ERR_NOT_IMPLEMENTED; | |
147 } | |
148 | |
149 private: | 140 private: |
150 scoped_refptr<net::IOBuffer> read_buffer_; | 141 scoped_refptr<net::IOBuffer> read_buffer_; |
151 int read_buffer_size_; | 142 int read_buffer_size_; |
152 net::CompletionCallback read_callback_; | 143 net::CompletionCallback read_callback_; |
153 | 144 |
154 std::deque<std::vector<char> > incoming_packets_; | 145 std::deque<std::vector<char> > incoming_packets_; |
155 | 146 |
156 FakeSocket* peer_socket_; | 147 FakeSocket* peer_socket_; |
157 RateLimiter* rate_limiter_; | 148 RateLimiter* rate_limiter_; |
158 int latency_ms_; | 149 int latency_ms_; |
159 }; | 150 }; |
160 | 151 |
161 class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> { | 152 class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> { |
162 public: | 153 public: |
163 TCPChannelTester(base::MessageLoop* message_loop, | 154 TCPChannelTester(base::MessageLoop* message_loop, |
164 net::Socket* client_socket, | 155 P2PStreamSocket* client_socket, |
165 net::Socket* host_socket) | 156 P2PStreamSocket* host_socket) |
166 : message_loop_(message_loop), | 157 : message_loop_(message_loop), |
167 host_socket_(host_socket), | 158 host_socket_(host_socket), |
168 client_socket_(client_socket), | 159 client_socket_(client_socket), |
169 done_(false), | 160 done_(false), |
170 write_errors_(0), | 161 write_errors_(0), |
171 read_errors_(0) {} | 162 read_errors_(0) {} |
172 | 163 |
173 void Start() { | 164 void Start() { |
174 message_loop_->PostTask( | 165 message_loop_->PostTask( |
175 FROM_HERE, base::Bind(&TCPChannelTester::DoStart, this)); | 166 FROM_HERE, base::Bind(&TCPChannelTester::DoStart, this)); |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 input_buffer_->SetCapacity(input_buffer_->capacity() + result); | 264 input_buffer_->SetCapacity(input_buffer_->capacity() + result); |
274 if (input_buffer_->capacity() == kTestDataSize + kMessageSize) | 265 if (input_buffer_->capacity() == kTestDataSize + kMessageSize) |
275 Done(); | 266 Done(); |
276 } | 267 } |
277 } | 268 } |
278 | 269 |
279 private: | 270 private: |
280 friend class base::RefCountedThreadSafe<TCPChannelTester>; | 271 friend class base::RefCountedThreadSafe<TCPChannelTester>; |
281 | 272 |
282 base::MessageLoop* message_loop_; | 273 base::MessageLoop* message_loop_; |
283 net::Socket* host_socket_; | 274 P2PStreamSocket* host_socket_; |
284 net::Socket* client_socket_; | 275 P2PStreamSocket* client_socket_; |
285 bool done_; | 276 bool done_; |
286 | 277 |
287 scoped_refptr<net::DrainableIOBuffer> output_buffer_; | 278 scoped_refptr<net::DrainableIOBuffer> output_buffer_; |
288 scoped_refptr<net::GrowableIOBuffer> input_buffer_; | 279 scoped_refptr<net::GrowableIOBuffer> input_buffer_; |
289 | 280 |
290 int write_errors_; | 281 int write_errors_; |
291 int read_errors_; | 282 int read_errors_; |
292 }; | 283 }; |
293 | 284 |
294 class PseudoTcpAdapterTest : public testing::Test { | 285 class PseudoTcpAdapterTest : public testing::Test { |
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
430 | 421 |
431 tester->Start(); | 422 tester->Start(); |
432 message_loop_.Run(); | 423 message_loop_.Run(); |
433 tester->CheckResults(); | 424 tester->CheckResults(); |
434 } | 425 } |
435 | 426 |
436 } // namespace | 427 } // namespace |
437 | 428 |
438 } // namespace protocol | 429 } // namespace protocol |
439 } // namespace remoting | 430 } // namespace remoting |
OLD | NEW |