Made the ChromotingHost class not ref-counted.

remoting/host/chromoting_host_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "media/video/capture/screen/screen_capturer_fake.h"
 #include "remoting/base/auto_thread_task_runner.h"
@@ skipping 49 matching lines @@
 }
 
 }  // namespace
 
 class ChromotingHostTest : public testing::Test {
  public:
   ChromotingHostTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    ui_task_runner_ = new AutoThreadTaskRunner(
+    task_runner_ = new AutoThreadTaskRunner(
         message_loop_.message_loop_proxy(),
         base::Bind(&ChromotingHostTest::QuitMainMessageLoop,
                    base::Unretained(this)));
 
     desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
     EXPECT_CALL(*desktop_environment_factory_, CreatePtr())
         .Times(AnyNumber())
         .WillRepeatedly(Invoke(this,
                                &ChromotingHostTest::CreateDesktopEnvironment));
     EXPECT_CALL(*desktop_environment_factory_, SupportsAudioCapture())
         .Times(AnyNumber())
         .WillRepeatedly(Return(false));
 
     session_manager_ = new protocol::MockSessionManager();
 
-    host_ = new ChromotingHost(
+    host_.reset(new ChromotingHost(
         &signal_strategy_,
         desktop_environment_factory_.get(),
         scoped_ptr<protocol::SessionManager>(session_manager_),
-        ui_task_runner_,  // Audio
-        ui_task_runner_,  // Input
-        ui_task_runner_,  // Video capture
-        ui_task_runner_,  // Video encode
-        ui_task_runner_,  // Network
-        ui_task_runner_); // UI
+        task_runner_,   // Audio
+        task_runner_,   // Input
+        task_runner_,   // Video capture
+        task_runner_,   // Video encode
+        task_runner_,   // Network
+        task_runner_)); // UI
     host_->AddStatusObserver(&host_status_observer_);
 
     xmpp_login_ = "host@domain";
     session1_ = new MockSession();
     session2_ = new MockSession();
     session_unowned1_.reset(new MockSession());
     session_unowned2_.reset(new MockSession());
     session_config1_ = SessionConfig::ForTest();
     session_jid1_ = "user@domain/rest-of-jid";
     session_config2_ = SessionConfig::ForTest();
@@ skipping 69 matching lines @@
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
     scoped_ptr<protocol::ConnectionToClient> connection =
         ((connection_index == 0) ? owned_connection1_ : owned_connection2_).
         PassAs<protocol::ConnectionToClient>();
     protocol::ConnectionToClient* connection_ptr = connection.get();
     scoped_ptr<ClientSession> client(new ClientSession(
         host_.get(),
-        ui_task_runner_,  // Audio
-        ui_task_runner_,  // Input
-        ui_task_runner_,  // Video capture
-        ui_task_runner_,  // Video encode
-        ui_task_runner_,  // Network
-        ui_task_runner_,  // UI
+        task_runner_, // Audio
+        task_runner_, // Input
+        task_runner_, // Video capture
+        task_runner_, // Video encode
+        task_runner_, // Network
+        task_runner_, // UI
         connection.Pass(),
         desktop_environment_factory_.get(),
         base::TimeDelta()));
 
-    ClientSession* client_raw = client.get();
-    connection_ptr->set_host_stub(client_raw);
-
-    ui_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
-                              host_, base::Passed(&client)));
+    connection_ptr->set_host_stub(client.get());
 
     if (authenticate) {
-      ui_task_runner_->PostTask(
-          FROM_HERE, base::Bind(&ClientSession::OnConnectionAuthenticated,
-                                base::Unretained(client_raw), connection_ptr));
+      task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&ClientSession::OnConnectionAuthenticated,
+                     base::Unretained(client.get()), connection_ptr));
       if (!reject) {
-        ui_task_runner_->PostTask(
+        task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&ClientSession::OnConnectionChannelsConnected,
-                       base::Unretained(client_raw), connection_ptr));
+                       base::Unretained(client.get()), connection_ptr));
       }
     } else {
-      ui_task_runner_->PostTask(
+      task_runner_->PostTask(
           FROM_HERE, base::Bind(&ClientSession::OnConnectionClosed,
-                                base::Unretained(client_raw), connection_ptr,
+                                base::Unretained(client.get()), connection_ptr,
                                 protocol::AUTHENTICATION_FAILED));
     }
 
-    get_client(connection_index) = client_raw;
+    get_client(connection_index) = client.get();
+
+    // |host| is responsible for deleting |client| from now on.
+    host_->clients_.push_back(client.release());
   }
 
   virtual void TearDown() OVERRIDE {
     // Make sure that the host has been properly deleted.
     DCHECK(host_.get() == NULL);
   }
 
   // Change the session route for |client1_|.
   void ChangeSessionRoute(const std::string& channel_name,
                           const protocol::TransportRoute& route) {
@@ skipping 55 matching lines @@
   void SetEventHandler(protocol::Session::EventHandler* event_handler) {
     session_event_handler_ = event_handler;
   }
 
   void NotifyConnectionClosed() {
     if (session_event_handler_) {
       session_event_handler_->OnSessionStateChange(protocol::Session::CLOSED);
     }
   }
 
-  static void AddClientToHost(scoped_refptr<ChromotingHost> host,
-                              scoped_ptr<ClientSession> client) {
-    // |host| is responsible for deleting |client| from now on.
-    host->clients_.push_back(client.release());
+  void ShutdownHost() {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromotingHostTest::StopAndReleaseTaskRunner,
+                   base::Unretained(this)));
   }
 
-  void ShutdownHost() {
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromotingHost::Shutdown, host_,
-                   base::Bind(&ChromotingHostTest::ReleaseUiTaskRunner,
-                              base::Unretained(this))));
-  }
-
-  void ReleaseUiTaskRunner() {
-    ui_task_runner_ = NULL;
-    host_ = NULL;
+  void StopAndReleaseTaskRunner() {
+    host_.reset();
+    task_runner_ = NULL;
     desktop_environment_factory_.reset();
   }
 
   void QuitMainMessageLoop() {
     PostQuitTask(&message_loop_);
   }
 
   // Expect the host and session manager to start, and return the expectation
   // that the session manager has started.
   Expectation ExpectHostAndSessionManagerStart() {
@@ skipping 65 matching lines @@
     if (expect_host_status_change) {
       EXPECT_CALL(host_status_observer_, OnClientDisconnected(session_jid))
           .After(after)
           .WillOnce(action)
           .RetiresOnSaturation();
     }
   }
 
  protected:
   MessageLoop message_loop_;
-  scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
+  scoped_refptr<AutoThreadTaskRunner> task_runner_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
-  scoped_refptr<ChromotingHost> host_;
+  scoped_ptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   MockConnectionToClient* connection1_;
   scoped_ptr<MockConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
   SessionConfig session_config1_;
   MockVideoStub video_stub1_;
@@ skipping 236 matching lines @@
   ExpectClientDisconnected(0, true, video_packet_sent,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 }  // namespace remoting