Cleanup Fake* classes in remoting/protocol

remoting/protocol/channel_multiplexer_unittest.cc

 // Copyright (c) 2012 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/channel_multiplexer.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "net/base/net_errors.h"
@@ skipping 54 matching lines @@
   }
 
   void DeleteAfterSessionFail() {
     host_mux_->CancelChannelCreation(kTestChannelName2);
     DeleteAll();
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     // Create pair of multiplexers and connect them to each other.
-    host_mux_.reset(new ChannelMultiplexer(&host_session_, kMuxChannelName));
-    client_mux_.reset(new ChannelMultiplexer(&client_session_,
-                                             kMuxChannelName));
+    host_mux_.reset(new ChannelMultiplexer(
+        host_session_.GetTransportChannelFactory(), kMuxChannelName));
+    client_mux_.reset(new ChannelMultiplexer(
+        client_session_.GetTransportChannelFactory(), kMuxChannelName));
   }
 
   // Connect sockets to each other. Must be called after we've created at least
   // one channel with each multiplexer.
   void ConnectSockets() {
-    FakeSocket* host_socket =
-        host_session_.GetStreamChannel(ChannelMultiplexer::kMuxChannelName);
-    FakeSocket* client_socket =
-        client_session_.GetStreamChannel(ChannelMultiplexer::kMuxChannelName);
+    FakeStreamSocket* host_socket =
+        host_session_.fake_channel_factory().GetFakeChannel(
+            ChannelMultiplexer::kMuxChannelName);
+    FakeStreamSocket* client_socket =
+        client_session_.fake_channel_factory().GetFakeChannel(
+            ChannelMultiplexer::kMuxChannelName);
     host_socket->PairWith(client_socket);
 
     // Make writes asynchronous in one direction.
     host_socket->set_async_write(true);
   }
 
   void CreateChannel(const std::string& name,
                      scoped_ptr<net::StreamSocket>* host_socket,
                      scoped_ptr<net::StreamSocket>* client_socket) {
     int counter = 2;
@@ skipping 138 matching lines @@
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 
   scoped_ptr<net::StreamSocket> host_socket2_;
   scoped_ptr<net::StreamSocket> client_socket2_;
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
   ConnectSockets();
 
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_next_write_error(net::ERR_FAILED);
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_async_write(false);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
 
   EXPECT_CALL(cb1, OnDone(_))
       .Times(0);
   EXPECT_CALL(cb2, OnDone(_))
@@ skipping 15 matching lines @@
 
 TEST_F(ChannelMultiplexerTest, WriteFailAsync) {
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
 
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
   ConnectSockets();
 
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_next_write_error(net::ERR_FAILED);
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_async_write(true);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED));
   EXPECT_CALL(cb2, OnDone(net::ERR_FAILED));
 
   EXPECT_EQ(net::ERR_IO_PENDING,
@@ skipping 11 matching lines @@
 }
 
 TEST_F(ChannelMultiplexerTest, DeleteWhenFailed) {
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName, &host_socket1_, &client_socket1_));
   ASSERT_NO_FATAL_FAILURE(
       CreateChannel(kTestChannelName2, &host_socket2_, &client_socket2_));
 
   ConnectSockets();
 
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_next_write_error(net::ERR_FAILED);
-  host_session_.GetStreamChannel(kMuxChannelName)->
+  host_session_.fake_channel_factory().GetFakeChannel(kMuxChannelName)->
       set_async_write(true);
 
   scoped_refptr<net::IOBufferWithSize> buf = CreateTestBuffer(100);
 
   MockSocketCallback cb1;
   MockSocketCallback cb2;
 
   EXPECT_CALL(cb1, OnDone(net::ERR_FAILED))
       .Times(AtMost(1))
       .WillOnce(InvokeWithoutArgs(this, &ChannelMultiplexerTest::DeleteAll));
@@ skipping 12 matching lines @@
                                  base::Bind(&MockSocketCallback::OnDone,
                                             base::Unretained(&cb2))));
 
   base::RunLoop().RunUntilIdle();
 
   // Check that the sockets were destroyed.
   EXPECT_FALSE(host_mux_.get());
 }
 
 TEST_F(ChannelMultiplexerTest, SessionFail) {
-  host_session_.set_async_creation(true);
-  host_session_.set_error(AUTHENTICATION_FAILED);
+  host_session_.fake_channel_factory().set_asynchronous_create(true);
+  host_session_.fake_channel_factory().set_fail_create(true);
 
   MockConnectCallback cb1;
   MockConnectCallback cb2;
 
   host_mux_->CreateChannel(kTestChannelName, base::Bind(
       &MockConnectCallback::OnConnected, base::Unretained(&cb1)));
   host_mux_->CreateChannel(kTestChannelName2, base::Bind(
       &MockConnectCallback::OnConnected, base::Unretained(&cb2)));
 
   EXPECT_CALL(cb1, OnConnectedPtr(NULL))
       .Times(AtMost(1))
       .WillOnce(InvokeWithoutArgs(
           this, &ChannelMultiplexerTest::DeleteAfterSessionFail));
   EXPECT_CALL(cb2, OnConnectedPtr(_))
       .Times(0);
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace protocol
 }  // namespace remoting