OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/fake_stream_socket.h" | 5 #include "remoting/protocol/fake_stream_socket.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback_helpers.h" | 8 #include "base/callback_helpers.h" |
9 #include "base/single_thread_task_runner.h" | 9 #include "base/single_thread_task_runner.h" |
10 #include "base/thread_task_runner_handle.h" | 10 #include "base/thread_task_runner_handle.h" |
(...skipping 13 matching lines...) Expand all Loading... | |
24 next_write_error_(net::OK), | 24 next_write_error_(net::OK), |
25 next_read_error_(net::OK), | 25 next_read_error_(net::OK), |
26 read_buffer_size_(0), | 26 read_buffer_size_(0), |
27 input_pos_(0), | 27 input_pos_(0), |
28 task_runner_(base::ThreadTaskRunnerHandle::Get()), | 28 task_runner_(base::ThreadTaskRunnerHandle::Get()), |
29 weak_factory_(this) { | 29 weak_factory_(this) { |
30 } | 30 } |
31 | 31 |
32 FakeStreamSocket::~FakeStreamSocket() { | 32 FakeStreamSocket::~FakeStreamSocket() { |
33 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | 33 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); |
34 if (peer_socket_.get()) { | |
Wez
2015/06/22 15:49:07
nit: Remove .get()
Sergey Ulanov
2015/07/10 00:49:54
Done.
| |
35 task_runner_->PostTask( | |
36 FROM_HERE, base::Bind(&FakeStreamSocket::AppendReadError, peer_socket_, | |
37 net::ERR_CONNECTION_CLOSED)); | |
38 } | |
34 } | 39 } |
35 | 40 |
36 void FakeStreamSocket::AppendInputData(const std::string& data) { | 41 void FakeStreamSocket::AppendInputData(const std::string& data) { |
37 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | 42 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); |
38 input_data_.insert(input_data_.end(), data.begin(), data.end()); | 43 input_data_.insert(input_data_.end(), data.begin(), data.end()); |
39 // Complete pending read if any. | 44 // Complete pending read if any. |
40 if (!read_callback_.is_null()) { | 45 if (!read_callback_.is_null()) { |
41 int result = std::min(read_buffer_size_, | 46 int result = std::min(read_buffer_size_, |
42 static_cast<int>(input_data_.size() - input_pos_)); | 47 static_cast<int>(input_data_.size() - input_pos_)); |
43 EXPECT_GT(result, 0); | 48 EXPECT_GT(result, 0); |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
152 NOTIMPLEMENTED(); | 157 NOTIMPLEMENTED(); |
153 return net::ERR_NOT_IMPLEMENTED; | 158 return net::ERR_NOT_IMPLEMENTED; |
154 } | 159 } |
155 | 160 |
156 int FakeStreamSocket::SetSendBufferSize(int32 size) { | 161 int FakeStreamSocket::SetSendBufferSize(int32 size) { |
157 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | 162 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); |
158 NOTIMPLEMENTED(); | 163 NOTIMPLEMENTED(); |
159 return net::ERR_NOT_IMPLEMENTED; | 164 return net::ERR_NOT_IMPLEMENTED; |
160 } | 165 } |
161 | 166 |
162 int FakeStreamSocket::Connect(const net::CompletionCallback& callback) { | |
163 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
164 return net::OK; | |
165 } | |
166 | |
167 void FakeStreamSocket::Disconnect() { | |
168 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
169 | |
170 if (peer_socket_.get()) { | |
171 task_runner_->PostTask( | |
172 FROM_HERE, | |
173 base::Bind(&FakeStreamSocket::AppendReadError, | |
174 peer_socket_, | |
175 net::ERR_CONNECTION_CLOSED)); | |
176 } | |
177 peer_socket_.reset(); | |
178 } | |
179 | |
180 bool FakeStreamSocket::IsConnected() const { | |
181 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
182 return true; | |
183 } | |
184 | |
185 bool FakeStreamSocket::IsConnectedAndIdle() const { | |
186 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
187 NOTIMPLEMENTED(); | |
188 return false; | |
189 } | |
190 | |
191 int FakeStreamSocket::GetPeerAddress(net::IPEndPoint* address) const { | |
192 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
193 net::IPAddressNumber ip(net::kIPv4AddressSize); | |
194 *address = net::IPEndPoint(ip, 0); | |
195 return net::OK; | |
196 } | |
197 | |
198 int FakeStreamSocket::GetLocalAddress(net::IPEndPoint* address) const { | |
199 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
200 NOTIMPLEMENTED(); | |
201 return net::ERR_NOT_IMPLEMENTED; | |
202 } | |
203 | |
204 const net::BoundNetLog& FakeStreamSocket::NetLog() const { | |
205 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
206 return net_log_; | |
207 } | |
208 | |
209 void FakeStreamSocket::SetSubresourceSpeculation() { | |
210 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
211 NOTIMPLEMENTED(); | |
212 } | |
213 | |
214 void FakeStreamSocket::SetOmniboxSpeculation() { | |
215 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
216 NOTIMPLEMENTED(); | |
217 } | |
218 | |
219 bool FakeStreamSocket::WasEverUsed() const { | |
220 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
221 NOTIMPLEMENTED(); | |
222 return true; | |
223 } | |
224 | |
225 bool FakeStreamSocket::UsingTCPFastOpen() const { | |
226 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
227 NOTIMPLEMENTED(); | |
228 return true; | |
229 } | |
230 | |
231 bool FakeStreamSocket::WasNpnNegotiated() const { | |
232 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
233 return false; | |
234 } | |
235 | |
236 net::NextProto FakeStreamSocket::GetNegotiatedProtocol() const { | |
237 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
238 NOTIMPLEMENTED(); | |
239 return net::kProtoUnknown; | |
240 } | |
241 | |
242 bool FakeStreamSocket::GetSSLInfo(net::SSLInfo* ssl_info) { | |
243 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
244 return false; | |
245 } | |
246 | |
247 void FakeStreamSocket::GetConnectionAttempts( | |
248 net::ConnectionAttempts* out) const { | |
249 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); | |
250 out->clear(); | |
251 } | |
252 | |
253 FakeStreamChannelFactory::FakeStreamChannelFactory() | 167 FakeStreamChannelFactory::FakeStreamChannelFactory() |
254 : task_runner_(base::ThreadTaskRunnerHandle::Get()), | 168 : task_runner_(base::ThreadTaskRunnerHandle::Get()), |
255 asynchronous_create_(false), | 169 asynchronous_create_(false), |
256 fail_create_(false), | 170 fail_create_(false), |
257 weak_factory_(this) { | 171 weak_factory_(this) { |
258 } | 172 } |
259 | 173 |
260 FakeStreamChannelFactory::~FakeStreamChannelFactory() {} | 174 FakeStreamChannelFactory::~FakeStreamChannelFactory() {} |
261 | 175 |
262 FakeStreamSocket* FakeStreamChannelFactory::GetFakeChannel( | 176 FakeStreamSocket* FakeStreamChannelFactory::GetFakeChannel( |
(...skipping 26 matching lines...) Expand all Loading... | |
289 if (channels_.find(name) != channels_.end()) | 203 if (channels_.find(name) != channels_.end()) |
290 callback.Run(owned_channel.Pass()); | 204 callback.Run(owned_channel.Pass()); |
291 } | 205 } |
292 | 206 |
293 void FakeStreamChannelFactory::CancelChannelCreation(const std::string& name) { | 207 void FakeStreamChannelFactory::CancelChannelCreation(const std::string& name) { |
294 channels_.erase(name); | 208 channels_.erase(name); |
295 } | 209 } |
296 | 210 |
297 } // namespace protocol | 211 } // namespace protocol |
298 } // namespace remoting | 212 } // namespace remoting |
OLD | NEW |