remoting/protocol/fake_session.cc

   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@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