Cleanup ChannelMultiplexer tests to avoid dependency on FakeSession.

remoting/protocol/fake_stream_socket.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/fake_stream_socket.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace protocol {
 
 FakeStreamSocket::FakeStreamSocket()
-    : async_write_(false),
-      write_pending_(false),
-      write_limit_(0),
-      next_write_error_(net::OK),
-      next_read_error_(net::OK),
-      read_buffer_size_(0),
-      input_pos_(0),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      weak_factory_(this) {
-}
+    : task_runner_(base::ThreadTaskRunnerHandle::Get()), weak_factory_(this) {}
 
 FakeStreamSocket::~FakeStreamSocket() {
   EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   if (peer_socket_) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&FakeStreamSocket::AppendReadError, peer_socket_,
                               net::ERR_CONNECTION_CLOSED));
   }
 }
 
@@ skipping 109 matching lines @@
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FakeStreamSocket::AppendInputData,
                    peer_socket_,
                    std::string(buf->data(), buf->data() + buf_len)));
   }
 }
 
 FakeStreamChannelFactory::FakeStreamChannelFactory()
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      asynchronous_create_(false),
-      fail_create_(false),
       weak_factory_(this) {
 }
 
 FakeStreamChannelFactory::~FakeStreamChannelFactory() {}
 
 FakeStreamSocket* FakeStreamChannelFactory::GetFakeChannel(
     const std::string& name) {
   return channels_[name].get();
 }
 
 void FakeStreamChannelFactory::PairWith(
     FakeStreamChannelFactory* peer_factory) {
   peer_factory_ = peer_factory->weak_factory_.GetWeakPtr();
   peer_factory->peer_factory_ = weak_factory_.GetWeakPtr();
 }
 
 void FakeStreamChannelFactory::CreateChannel(
     const std::string& name,
     const ChannelCreatedCallback& callback) {
   scoped_ptr<FakeStreamSocket> channel(new FakeStreamSocket());
   channels_[name] = channel->GetWeakPtr();
+  channel->set_async_write(async_write_);
 
   if (peer_factory_) {
     FakeStreamSocket* peer_channel = peer_factory_->GetFakeChannel(name);
     if (peer_channel)
       channel->PairWith(peer_channel);
   }
 
   if (fail_create_)
     channel.reset();
 
@@ skipping 13 matching lines @@
   if (channels_.find(name) != channels_.end())
     callback.Run(owned_channel.Pass());
 }
 
 void FakeStreamChannelFactory::CancelChannelCreation(const std::string& name) {
   channels_.erase(name);
 }
 
 }  // namespace protocol
 }  // namespace remoting