Move ConnectionToClient::EventHandler from ChromotingHost to ClientSession

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/task.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 83 matching lines @@
     local_input_monitor_ = new MockLocalInputMonitor();
     desktop_environment_.reset(
         new DesktopEnvironment(&context_, capturer, event_executor_, curtain_,
                                disconnect_window_, continue_window_,
                                local_input_monitor_));
     MockAccessVerifier* access_verifier = new MockAccessVerifier();
 
     host_ = ChromotingHost::Create(&context_, config_,
                                    desktop_environment_.get(),
                                    access_verifier, false);
-    connection_ = new MockConnectionToClient(
-        &handler_, &host_stub_, event_executor_);
-    connection2_ = new MockConnectionToClient(
-        &handler_, &host_stub2_, &event_executor2_);
-    session_.reset(new MockSession());
-    session2_.reset(new MockSession());
+    session_ = new MockSession();
+    session2_ = new MockSession();
     session_config_ = SessionConfig::GetDefault();
     session_jid_ = "user@domain/rest-of-jid";
     session2_jid_ = "user2@domain/rest-of-jid";
     session_config2_ = SessionConfig::GetDefault();
+    EXPECT_CALL(*session_, jid())
+        .WillRepeatedly(ReturnRef(session_jid_));
+    EXPECT_CALL(*session2_, jid())
+        .WillRepeatedly(ReturnRef(session2_jid_));
+    EXPECT_CALL(*session_, SetStateChangeCallback(_))
+        .Times(AnyNumber());
+    EXPECT_CALL(*session2_, SetStateChangeCallback(_))
+        .Times(AnyNumber());
+    EXPECT_CALL(*session_, config())
+        .WillRepeatedly(ReturnRef(session_config_));
+    EXPECT_CALL(*session2_, config())
+        .WillRepeatedly(ReturnRef(session_config2_));
+
+    connection_ = new MockConnectionToClient(
+        session_, &host_stub_, event_executor_);
+    connection2_ = new MockConnectionToClient(
+        session2_, &host_stub2_, &event_executor2_);
 
     ON_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(video_stub2_, ProcessVideoPacket(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(*connection_.get(), video_stub())
         .WillByDefault(Return(&video_stub_));
     ON_CALL(*connection_.get(), client_stub())
         .WillByDefault(Return(&client_stub_));
     ON_CALL(*connection_.get(), session())
-        .WillByDefault(Return(session_.get()));
+        .WillByDefault(Return(session_));
     ON_CALL(*connection2_.get(), video_stub())
         .WillByDefault(Return(&video_stub2_));
     ON_CALL(*connection2_.get(), client_stub())
         .WillByDefault(Return(&client_stub2_));
     ON_CALL(*connection2_.get(), session())
-        .WillByDefault(Return(session2_.get()));
-    ON_CALL(*session_.get(), config())
-        .WillByDefault(ReturnRef(session_config_));
-    ON_CALL(*session2_.get(), config())
-        .WillByDefault(ReturnRef(session_config2_));
-    EXPECT_CALL(*session_, jid())
-        .WillRepeatedly(ReturnRef(session_jid_));
-    EXPECT_CALL(*session2_, jid())
-        .WillRepeatedly(ReturnRef(session2_jid_));
+        .WillByDefault(Return(session2_));
     EXPECT_CALL(*connection_.get(), video_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection_.get(), client_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection_.get(), session())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_.get(), video_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_.get(), client_stub())
         .Times(AnyNumber());
     EXPECT_CALL(*connection2_.get(), session())
         .Times(AnyNumber());
-    EXPECT_CALL(*session_.get(), config())
-        .Times(AnyNumber());
-    EXPECT_CALL(*session2_.get(), config())
-        .Times(AnyNumber());
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunAllPending();
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate) {
-    scoped_refptr<MockConnectionToClient> connection =
+    scoped_refptr<protocol::ConnectionToClient> connection =
         (connection_index == 0) ? connection_ : connection2_;
-
     scoped_refptr<ClientSession> client = new ClientSession(
         host_.get(),
         connection,
         event_executor_,
         desktop_environment_->capturer());
     connection->set_host_stub(client.get());
 
     context_.network_message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableFunction(&ChromotingHostTest::AddClientToHost,
-                            host_, client));
+        FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
+                              host_, client));
     if (authenticate) {
       context_.network_message_loop()->PostTask(
-          FROM_HERE,
-          NewRunnableMethod(client.get(),
-                            &ClientSession::OnAuthenticationComplete));
+          FROM_HERE, base::Bind(&ClientSession::OnConnectionOpened,
+                                client.get(), connection));
+    }
+
+    if (connection_index == 0) {
+      client_ = client;
+    } else {
+      client2_ = client;
     }
   }
 
   // Helper method to remove a client connection from ChromotingHost.
-  void RemoveClientConnection() {
+  void RemoveClientSession() {
     context_.network_message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(host_.get(),
-                          &ChromotingHost::OnClientDisconnected,
-                          connection_));
+        FROM_HERE, base::Bind(
+            &ClientSession::OnConnectionClosed, client_, connection_));
   }
 
   static void AddClientToHost(scoped_refptr<ChromotingHost> host,
                               scoped_refptr<ClientSession> session) {
     host->clients_.push_back(session);
   }
 
   void ShutdownHost() {
     host_->Shutdown(
         NewRunnableFunction(&PostQuitTask, &message_loop_));
   }
 
  protected:
   MessageLoop message_loop_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   MockConnectionToClientEventHandler handler_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_refptr<ChromotingHost> host_;
   scoped_refptr<InMemoryHostConfig> config_;
   MockChromotingHostContext context_;
   scoped_refptr<MockConnectionToClient> connection_;
+  scoped_refptr<ClientSession> client_;
   std::string session_jid_;
-  scoped_ptr<MockSession> session_;
+  MockSession* session_;  // Owned by |connection_|.
   SessionConfig session_config_;
   MockVideoStub video_stub_;
   MockClientStub client_stub_;
   MockHostStub host_stub_;
   scoped_refptr<MockConnectionToClient> connection2_;
+  scoped_refptr<ClientSession> client2_;
   std::string session2_jid_;
-  scoped_ptr<MockSession> session2_;
+  MockSession* session2_;  // Owned by |connection2_|.
   SessionConfig session_config2_;
   MockVideoStub video_stub2_;
   MockClientStub client_stub2_;
   MockHostStub host_stub2_;
   MockEventExecutor event_executor2_;
 
   // Owned by |host_|.
   MockEventExecutor* event_executor_;
   MockCurtain* curtain_;
   MockDisconnectWindow* disconnect_window_;
   MockContinueWindow* continue_window_;
   MockLocalInputMonitor* local_input_monitor_;
 };
 
 TEST_F(ChromotingHostTest, DISABLED_StartAndShutdown) {
   host_->Start();
 
   message_loop_.PostTask(
-      FROM_HERE,NewRunnableMethod(
+      FROM_HERE, NewRunnableMethod(
           host_.get(), &ChromotingHost::Shutdown,
           NewRunnableFunction(&PostQuitTask, &message_loop_)));
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, DISABLED_Connect) {
   host_->Start();
 
   // When the video packet is received we first shutdown ChromotingHost
   // then execute the done task.
@@ skipping 24 matching lines @@
   // connection.
   {
     InSequence s;
     // Ensure that curtain mode is activated before the first video packet.
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
         .Times(1);
     EXPECT_CALL(*disconnect_window_, Show(_, _))
         .Times(0);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
-            InvokeWithoutArgs(this,
-                              &ChromotingHostTest::RemoveClientConnection),
+            InvokeWithoutArgs(this, &ChromotingHostTest::RemoveClientSession),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
     EXPECT_CALL(*curtain_, EnableCurtainMode(false))
         .Times(1);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .Times(AnyNumber());
   }
 
@@ skipping 78 matching lines @@
 
   // Ensure that curtain mode is not activated if a connection does not
   // authenticate.
   EXPECT_CALL(*curtain_, EnableCurtainMode(_))
       .Times(0);
   EXPECT_CALL(*disconnect_window_, Show(_, _))
       .Times(0);
   EXPECT_CALL(*connection_.get(), Disconnect())
       .WillOnce(QuitMainMessageLoop(&message_loop_));
   SimulateClientConnection(0, false);
-  RemoveClientConnection();
+  RemoveClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, CurtainModeFailSecond) {
   host_->Start();
 
   // When a video packet is received we connect the second mock
   // connection.
   {
     InSequence s;
@@ skipping 45 matching lines @@
         .InSequence(s1);
     EXPECT_CALL(*local_input_monitor_, Start(_))
         .Times(1)
         .InSequence(s2);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .InSequence(s1, s2)
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost),
             RunDoneTask()))
         .RetiresOnSaturation();
-    EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
-        .Times(AnyNumber())
-        .InSequence(s1, s2);
     EXPECT_CALL(*connection_.get(), Disconnect())
         .InSequence(s1, s2)
         .RetiresOnSaturation();
     EXPECT_CALL(*local_input_monitor_, Stop())
         .Times(1)
         .InSequence(s1, s2);
     EXPECT_CALL(*continue_window_, Hide())
         .Times(1)
         .InSequence(s1);
     EXPECT_CALL(*disconnect_window_, Hide())
         .Times(1)
         .InSequence(s2);
   }
   SimulateClientConnection(0, true);
   message_loop_.Run();
   host_->set_it2me(false);
   EXPECT_THAT(curtain_activated, false);
 }
 
 }  // namespace remoting