1 // Copyright (c) 2012 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_session.h" 6 7 #include "base/bind.h" 8 #include "base/message_loop/message_loop.h" 9 #include "net/base/address_list.h" 10 #include "net/base/io_buffer.h" 11 #include "net/base/net_errors.h" 12 #include "net/base/net_util.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 namespace remoting { 16 namespace protocol { 17 18 const char kTestJid[] = "host1 (at) gmail.com/chromoting123"; 19 20 FakeSocket::FakeSocket() 21 : async_write_(false), 22 write_pending_(false), 23 write_limit_(0), 24 next_write_error_(net::OK), 25 next_read_error_(net::OK), 26 read_pending_(false), 27 read_buffer_size_(0), 28 input_pos_(0), 29 message_loop_(base::MessageLoop::current()), 30 weak_factory_(this) { 31 } 32 33 FakeSocket::~FakeSocket() { 34 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 35 } 36 37 void FakeSocket::AppendInputData(const std::vector<char>& data) { 38 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 39 input_data_.insert(input_data_.end(), data.begin(), data.end()); 40 // Complete pending read if any. 41 if (read_pending_) { 42 read_pending_ = false; 43 int result = std::min(read_buffer_size_, 44 static_cast<int>(input_data_.size() - input_pos_)); 45 CHECK(result > 0); 46 memcpy(read_buffer_->data(), 47 &(*input_data_.begin()) + input_pos_, result); 48 input_pos_ += result; 49 read_buffer_ = NULL; 50 read_callback_.Run(result); 51 } 52 } 53 54 void FakeSocket::PairWith(FakeSocket* peer_socket) { 55 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 56 peer_socket_ = peer_socket->weak_factory_.GetWeakPtr(); 57 peer_socket->peer_socket_ = weak_factory_.GetWeakPtr(); 58 } 59 60 int FakeSocket::Read(net::IOBuffer* buf, int buf_len, 61 const net::CompletionCallback& callback) { 62 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 63 64 if (next_read_error_ != net::OK) { 65 int r = next_read_error_; 66 next_read_error_ = net::OK; 67 return r; 68 } 69 70 if (input_pos_ < static_cast<int>(input_data_.size())) { 71 int result = std::min(buf_len, 72 static_cast<int>(input_data_.size()) - input_pos_); 73 memcpy(buf->data(), &(*input_data_.begin()) + input_pos_, result); 74 input_pos_ += result; 75 return result; 76 } else { 77 read_pending_ = true; 78 read_buffer_ = buf; 79 read_buffer_size_ = buf_len; 80 read_callback_ = callback; 81 return net::ERR_IO_PENDING; 82 } 83 } 84 85 int FakeSocket::Write(net::IOBuffer* buf, int buf_len, 86 const net::CompletionCallback& callback) { 87 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 88 EXPECT_FALSE(write_pending_); 89 90 if (write_limit_ > 0) 91 buf_len = std::min(write_limit_, buf_len); 92 93 if (async_write_) { 94 message_loop_->PostTask(FROM_HERE, base::Bind( 95 &FakeSocket::DoAsyncWrite, weak_factory_.GetWeakPtr(), 96 scoped_refptr<net::IOBuffer>(buf), buf_len, callback)); 97 write_pending_ = true; 98 return net::ERR_IO_PENDING; 99 } else { 100 if (next_write_error_ != net::OK) { 101 int r = next_write_error_; 102 next_write_error_ = net::OK; 103 return r; 104 } 105 106 DoWrite(buf, buf_len); 107 return buf_len; 108 } 109 } 110 111 void FakeSocket::DoAsyncWrite(scoped_refptr<net::IOBuffer> buf, int buf_len, 112 const net::CompletionCallback& callback) { 113 write_pending_ = false; 114 115 if (next_write_error_ != net::OK) { 116 int r = next_write_error_; 117 next_write_error_ = net::OK; 118 callback.Run(r); 119 return; 120 } 121 122 DoWrite(buf.get(), buf_len); 123 callback.Run(buf_len); 124 } 125 126 void FakeSocket::DoWrite(net::IOBuffer* buf, int buf_len) { 127 written_data_.insert(written_data_.end(), 128 buf->data(), buf->data() + buf_len); 129 130 if (peer_socket_.get()) { 131 message_loop_->PostTask( 132 FROM_HERE, 133 base::Bind(&FakeSocket::AppendInputData, 134 peer_socket_, 135 std::vector<char>(buf->data(), buf->data() + buf_len))); 136 } 137 } 138 139 int FakeSocket::SetReceiveBufferSize(int32 size) { 140 NOTIMPLEMENTED(); 141 return net::ERR_NOT_IMPLEMENTED; 142 } 143 144 int FakeSocket::SetSendBufferSize(int32 size) { 145 NOTIMPLEMENTED(); 146 return net::ERR_NOT_IMPLEMENTED; 147 } 148 149 int FakeSocket::Connect(const net::CompletionCallback& callback) { 150 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 151 return net::OK; 152 } 153 154 void FakeSocket::Disconnect() { 155 peer_socket_.reset(); 156 } 157 158 bool FakeSocket::IsConnected() const { 159 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 160 return true; 161 } 162 163 bool FakeSocket::IsConnectedAndIdle() const { 164 NOTIMPLEMENTED(); 165 return false; 166 } 167 168 int FakeSocket::GetPeerAddress(net::IPEndPoint* address) const { 169 net::IPAddressNumber ip(net::kIPv4AddressSize); 170 *address = net::IPEndPoint(ip, 0); 171 return net::OK; 172 } 173 174 int FakeSocket::GetLocalAddress(net::IPEndPoint* address) const { 175 NOTIMPLEMENTED(); 176 return net::ERR_NOT_IMPLEMENTED; 177 } 178 179 const net::BoundNetLog& FakeSocket::NetLog() const { 180 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 181 return net_log_; 182 } 183 184 void FakeSocket::SetSubresourceSpeculation() { 185 NOTIMPLEMENTED(); 186 } 187 188 void FakeSocket::SetOmniboxSpeculation() { 189 NOTIMPLEMENTED(); 190 } 191 192 bool FakeSocket::WasEverUsed() const { 193 NOTIMPLEMENTED(); 194 return true; 195 } 196 197 bool FakeSocket::UsingTCPFastOpen() const { 198 NOTIMPLEMENTED(); 199 return true; 200 } 201 202 bool FakeSocket::WasNpnNegotiated() const { 203 return false; 204 } 205 206 net::NextProto FakeSocket::GetNegotiatedProtocol() const { 207 NOTIMPLEMENTED(); 208 return net::kProtoUnknown; 209 } 210 211 bool FakeSocket::GetSSLInfo(net::SSLInfo* ssl_info) { 212 return false; 213 } 214 215 FakeUdpSocket::FakeUdpSocket() 216 : read_pending_(false), 217 input_pos_(0), 218 message_loop_(base::MessageLoop::current()) { 219 } 220 221 FakeUdpSocket::~FakeUdpSocket() { 222 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 223 } 224 225 void FakeUdpSocket::AppendInputPacket(const char* data, int data_size) { 226 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 227 input_packets_.push_back(std::string()); 228 input_packets_.back().assign(data, data + data_size); 229 230 // Complete pending read if any. 231 if (read_pending_) { 232 read_pending_ = false; 233 int result = std::min(data_size, read_buffer_size_); 234 memcpy(read_buffer_->data(), data, result); 235 input_pos_ = input_packets_.size(); 236 read_callback_.Run(result); 237 read_buffer_ = NULL; 238 } 239 } 240 241 int FakeUdpSocket::Read(net::IOBuffer* buf, int buf_len, 242 const net::CompletionCallback& callback) { 243 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 244 if (input_pos_ < static_cast<int>(input_packets_.size())) { 245 int result = std::min( 246 buf_len, static_cast<int>(input_packets_[input_pos_].size())); 247 memcpy(buf->data(), &(*input_packets_[input_pos_].begin()), result); 248 ++input_pos_; 249 return result; 250 } else { 251 read_pending_ = true; 252 read_buffer_ = buf; 253 read_buffer_size_ = buf_len; 254 read_callback_ = callback; 255 return net::ERR_IO_PENDING; 256 } 257 } 258 259 int FakeUdpSocket::Write(net::IOBuffer* buf, int buf_len, 260 const net::CompletionCallback& callback) { 261 EXPECT_EQ(message_loop_, base::MessageLoop::current()); 262 written_packets_.push_back(std::string()); 263 written_packets_.back().assign(buf->data(), buf->data() + buf_len); 264 return buf_len; 265 } 266 267 int FakeUdpSocket::SetReceiveBufferSize(int32 size) { 268 NOTIMPLEMENTED(); 269 return net::ERR_NOT_IMPLEMENTED; 270 } 271 272 int FakeUdpSocket::SetSendBufferSize(int32 size) { 273 NOTIMPLEMENTED(); 274 return net::ERR_NOT_IMPLEMENTED; 275 } 276 277 FakeSession::FakeSession() 278 : event_handler_(NULL), 279 candidate_config_(CandidateSessionConfig::CreateDefault()), 280 config_(SessionConfig::ForTest()), 281 message_loop_(base::MessageLoop::current()), 282 async_creation_(false), 283 jid_(kTestJid), 284 error_(OK), 285 closed_(false), 286 weak_factory_(this) { 287 } 288 289 FakeSession::~FakeSession() { } 290 291 FakeSocket* FakeSession::GetStreamChannel(const std::string& name) { 292 return stream_channels_[name]; 293 } 294 295 FakeUdpSocket* FakeSession::GetDatagramChannel(const std::string& name) { 296 return datagram_channels_[name]; 297 } 298 299 void FakeSession::SetEventHandler(EventHandler* event_handler) { 300 event_handler_ = event_handler; 301 } 302 303 ErrorCode FakeSession::error() { 304 return error_; 305 } 306 307 const std::string& FakeSession::jid() { 308 return jid_; 309 } 310 311 const CandidateSessionConfig* FakeSession::candidate_config() { 312 return candidate_config_.get(); 313 } 314 315 const SessionConfig& FakeSession::config() { 316 return config_; 317 } 318 319 void FakeSession::set_config(const SessionConfig& config) { 320 config_ = config; 321 } 322 323 ChannelFactory* FakeSession::GetTransportChannelFactory() { 324 return this; 325 } 326 327 ChannelFactory* FakeSession::GetMultiplexedChannelFactory() { 328 return this; 329 } 330 331 void FakeSession::Close() { 332 closed_ = true; 333 } 334 335 void FakeSession::CreateStreamChannel( 336 const std::string& name, 337 const StreamChannelCallback& callback) { 338 scoped_ptr<FakeSocket> channel; 339 // If we are in the error state then we put NULL in the channels list, so that 340 // NotifyStreamChannelCallback() still calls the callback. 341 if (error_ == OK) 342 channel.reset(new FakeSocket()); 343 stream_channels_[name] = channel.release(); 344 345 if (async_creation_) { 346 message_loop_->PostTask(FROM_HERE, base::Bind( 347 &FakeSession::NotifyStreamChannelCallback, weak_factory_.GetWeakPtr(), 348 name, callback)); 349 } else { 350 NotifyStreamChannelCallback(name, callback); 351 } 352 } 353 354 void FakeSession::NotifyStreamChannelCallback( 355 const std::string& name, 356 const StreamChannelCallback& callback) { 357 if (stream_channels_.find(name) != stream_channels_.end()) 358 callback.Run(scoped_ptr<net::StreamSocket>(stream_channels_[name])); 359 } 360 361 void FakeSession::CreateDatagramChannel( 362 const std::string& name, 363 const DatagramChannelCallback& callback) { 364 scoped_ptr<FakeUdpSocket> channel; 365 // If we are in the error state then we put NULL in the channels list, so that 366 // NotifyStreamChannelCallback() still calls the callback. 367 if (error_ == OK) 368 channel.reset(new FakeUdpSocket()); 369 datagram_channels_[name] = channel.release(); 370 371 if (async_creation_) { 372 message_loop_->PostTask(FROM_HERE, base::Bind( 373 &FakeSession::NotifyDatagramChannelCallback, weak_factory_.GetWeakPtr(), 374 name, callback)); 375 } else { 376 NotifyDatagramChannelCallback(name, callback); 377 } 378 } 379 380 void FakeSession::NotifyDatagramChannelCallback( 381 const std::string& name, 382 const DatagramChannelCallback& callback) { 383 if (datagram_channels_.find(name) != datagram_channels_.end()) 384 callback.Run(scoped_ptr<net::Socket>(datagram_channels_[name])); 385 } 386 387 void FakeSession::CancelChannelCreation(const std::string& name) { 388 stream_channels_.erase(name); 389 datagram_channels_.erase(name); 390 } 391 392 } // namespace protocol 393 } // namespace remoting 394
