remoting/protocol/fake_stream_socket.cc

   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_ = nullptr;
  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.Pass());
 270 }
 271
 272 void FakeStreamChannelFactory::CancelChannelCreation(const std::string& name) {
 273   channels_.erase(name);
 274 }
 275
 276 }  // namespace protocol
 277 }  // namespace remoting