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 3 // found in the LICENSE file. 4 5 #include "remoting/protocol/fake_stream_socket.h" 6 7 #include "base/bind.h" 8 #include "base/single_thread_task_runner.h" 9 #include "base/thread_task_runner_handle.h" 10 #include "net/base/address_list.h" 11 #include "net/base/io_buffer.h" 12 #include "net/base/net_errors.h" 13 #include "net/base/net_util.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 16 namespace remoting { 17 namespace protocol { 18 19 FakeStreamSocket::FakeStreamSocket() 20 : async_write_(false), 21 write_pending_(false), 22 write_limit_(0), 23 next_write_error_(net::OK), 24 next_read_error_(net::OK), 25 read_buffer_size_(0), 26 input_pos_(0), 27 task_runner_(base::ThreadTaskRunnerHandle::Get()), 28 weak_factory_(this) { 29 } 30 31 FakeStreamSocket::~FakeStreamSocket() { 32 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 33 } 34 35 void FakeStreamSocket::AppendInputData(const std::string& data) { 36 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 37 input_data_.insert(input_data_.end(), data.begin(), data.end()); 38 // Complete pending read if any. 39 if (!read_callback_.is_null()) { 40 int result = std::min(read_buffer_size_, 41 static_cast<int>(input_data_.size() - input_pos_)); 42 EXPECT_GT(result, 0); 43 memcpy(read_buffer_->data(), 44 &(*input_data_.begin()) + input_pos_, result); 45 input_pos_ += result; 46 read_buffer_ = NULL; 47 48 net::CompletionCallback callback = read_callback_; 49 read_callback_.Reset(); 50 callback.Run(result); 51 } 52 } 53 54 void FakeStreamSocket::PairWith(FakeStreamSocket* peer_socket) { 55 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 56 peer_socket_ = peer_socket->GetWeakPtr(); 57 peer_socket->peer_socket_ = GetWeakPtr(); 58 } 59 60 base::WeakPtr<FakeStreamSocket> FakeStreamSocket::GetWeakPtr() { 61 return weak_factory_.GetWeakPtr(); 62 } 63 64 int FakeStreamSocket::Read(net::IOBuffer* buf, int buf_len, 65 const net::CompletionCallback& callback) { 66 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 67 68 if (next_read_error_ != net::OK) { 69 int r = next_read_error_; 70 next_read_error_ = net::OK; 71 return r; 72 } 73 74 if (input_pos_ < static_cast<int>(input_data_.size())) { 75 int result = std::min(buf_len, 76 static_cast<int>(input_data_.size()) - input_pos_); 77 memcpy(buf->data(), &(*input_data_.begin()) + input_pos_, result); 78 input_pos_ += result; 79 return result; 80 } else { 81 read_buffer_ = buf; 82 read_buffer_size_ = buf_len; 83 read_callback_ = callback; 84 return net::ERR_IO_PENDING; 85 } 86 } 87 88 int FakeStreamSocket::Write(net::IOBuffer* buf, int buf_len, 89 const net::CompletionCallback& callback) { 90 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 91 EXPECT_FALSE(write_pending_); 92 93 if (write_limit_ > 0) 94 buf_len = std::min(write_limit_, buf_len); 95 96 if (async_write_) { 97 task_runner_->PostTask(FROM_HERE, base::Bind( 98 &FakeStreamSocket::DoAsyncWrite, weak_factory_.GetWeakPtr(), 99 scoped_refptr<net::IOBuffer>(buf), buf_len, callback)); 100 write_pending_ = true; 101 return net::ERR_IO_PENDING; 102 } else { 103 if (next_write_error_ != net::OK) { 104 int r = next_write_error_; 105 next_write_error_ = net::OK; 106 return r; 107 } 108 109 DoWrite(buf, buf_len); 110 return buf_len; 111 } 112 } 113 114 void FakeStreamSocket::DoAsyncWrite(scoped_refptr<net::IOBuffer> buf, 115 int buf_len, 116 const net::CompletionCallback& callback) { 117 write_pending_ = false; 118 119 if (next_write_error_ != net::OK) { 120 int r = next_write_error_; 121 next_write_error_ = net::OK; 122 callback.Run(r); 123 return; 124 } 125 126 DoWrite(buf.get(), buf_len); 127 callback.Run(buf_len); 128 } 129 130 void FakeStreamSocket::DoWrite(net::IOBuffer* buf, int buf_len) { 131 written_data_.insert(written_data_.end(), 132 buf->data(), buf->data() + buf_len); 133 134 if (peer_socket_.get()) { 135 task_runner_->PostTask( 136 FROM_HERE, 137 base::Bind(&FakeStreamSocket::AppendInputData, 138 peer_socket_, 139 std::string(buf->data(), buf->data() + buf_len))); 140 } 141 } 142 143 int FakeStreamSocket::SetReceiveBufferSize(int32 size) { 144 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 145 NOTIMPLEMENTED(); 146 return net::ERR_NOT_IMPLEMENTED; 147 } 148 149 int FakeStreamSocket::SetSendBufferSize(int32 size) { 150 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 151 NOTIMPLEMENTED(); 152 return net::ERR_NOT_IMPLEMENTED; 153 } 154 155 int FakeStreamSocket::Connect(const net::CompletionCallback& callback) { 156 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 157 return net::OK; 158 } 159 160 void FakeStreamSocket::Disconnect() { 161 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 162 peer_socket_.reset(); 163 } 164 165 bool FakeStreamSocket::IsConnected() const { 166 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 167 return true; 168 } 169 170 bool FakeStreamSocket::IsConnectedAndIdle() const { 171 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 172 NOTIMPLEMENTED(); 173 return false; 174 } 175 176 int FakeStreamSocket::GetPeerAddress(net::IPEndPoint* address) const { 177 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 178 net::IPAddressNumber ip(net::kIPv4AddressSize); 179 *address = net::IPEndPoint(ip, 0); 180 return net::OK; 181 } 182 183 int FakeStreamSocket::GetLocalAddress(net::IPEndPoint* address) const { 184 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 185 NOTIMPLEMENTED(); 186 return net::ERR_NOT_IMPLEMENTED; 187 } 188 189 const net::BoundNetLog& FakeStreamSocket::NetLog() const { 190 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 191 return net_log_; 192 } 193 194 void FakeStreamSocket::SetSubresourceSpeculation() { 195 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 196 NOTIMPLEMENTED(); 197 } 198 199 void FakeStreamSocket::SetOmniboxSpeculation() { 200 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 201 NOTIMPLEMENTED(); 202 } 203 204 bool FakeStreamSocket::WasEverUsed() const { 205 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 206 NOTIMPLEMENTED(); 207 return true; 208 } 209 210 bool FakeStreamSocket::UsingTCPFastOpen() const { 211 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 212 NOTIMPLEMENTED(); 213 return true; 214 } 215 216 bool FakeStreamSocket::WasNpnNegotiated() const { 217 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 218 return false; 219 } 220 221 net::NextProto FakeStreamSocket::GetNegotiatedProtocol() const { 222 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 223 NOTIMPLEMENTED(); 224 return net::kProtoUnknown; 225 } 226 227 bool FakeStreamSocket::GetSSLInfo(net::SSLInfo* ssl_info) { 228 EXPECT_TRUE(task_runner_->BelongsToCurrentThread()); 229 return false; 230 } 231 232 FakeStreamChannelFactory::FakeStreamChannelFactory() 233 : task_runner_(base::ThreadTaskRunnerHandle::Get()), 234 asynchronous_create_(false), 235 fail_create_(false), 236 weak_factory_(this) { 237 } 238 239 FakeStreamChannelFactory::~FakeStreamChannelFactory() {} 240 241 FakeStreamSocket* FakeStreamChannelFactory::GetFakeChannel( 242 const std::string& name) { 243 return channels_[name].get(); 244 } 245 246 void FakeStreamChannelFactory::CreateChannel( 247 const std::string& name, 248 const ChannelCreatedCallback& callback) { 249 scoped_ptr<FakeStreamSocket> channel(new FakeStreamSocket()); 250 channels_[name] = channel->GetWeakPtr(); 251 252 if (fail_create_) 253 channel.reset(); 254 255 if (asynchronous_create_) { 256 task_runner_->PostTask(FROM_HERE, base::Bind( 257 &FakeStreamChannelFactory::NotifyChannelCreated, 258 weak_factory_.GetWeakPtr(), base::Passed(&channel), name, callback)); 259 } else { 260 NotifyChannelCreated(channel.Pass(), name, callback); 261 } 262 } 263 264 void FakeStreamChannelFactory::NotifyChannelCreated( 265 scoped_ptr<FakeStreamSocket> owned_channel, 266 const std::string& name, 267 const ChannelCreatedCallback& callback) { 268 if (channels_.find(name) != channels_.end()) 269 callback.Run(owned_channel.PassAs<net::StreamSocket>()); 270 } 271 272 void FakeStreamChannelFactory::CancelChannelCreation(const std::string& name) { 273 channels_.erase(name); 274 } 275 276 } // namespace protocol 277 } // namespace remoting 278
