Access ChromotingHost::clients_ only on network thread.

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 138 matching lines @@
         .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());
   }
 
   virtual void TearDown() OVERRIDE {
+    connection_ = NULL;
+    client_ = NULL;
+    connection2_ = NULL;
+    client2_ = NULL;
+    host_ = NULL;
     message_loop_.RunAllPending();
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate) {
     scoped_refptr<protocol::ConnectionToClient> connection =
         (connection_index == 0) ? connection_ : connection2_;
     scoped_refptr<ClientSession> client = new ClientSession(
         host_.get(),
         connection,
@@ skipping 12 matching lines @@
 
     if (connection_index == 0) {
       client_ = client;
     } else {
       client2_ = client;
     }
   }
 
   // Helper method to remove a client connection from ChromotingHost.
   void RemoveClientSession() {
-    context_.network_message_loop()->PostTask(
-        FROM_HERE, base::Bind(
-            &ClientSession::OnConnectionClosed, client_, connection_));
+    client_->OnConnectionClosed(connection_);
   }
 
   static void AddClientToHost(scoped_refptr<ChromotingHost> host,
                               scoped_refptr<ClientSession> session) {
     host->clients_.push_back(session);
   }
 
   void ShutdownHost() {
-    host_->Shutdown(base::Bind(&PostQuitTask, &message_loop_));
+    message_loop_.PostTask(
+        FROM_HERE, base::Bind(&ChromotingHost::Shutdown, host_,
+                              base::Bind(&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_;
@@ skipping 161 matching lines @@
 
 TEST_F(ChromotingHostTest, CurtainModeFail) {
   host_->Start();
 
   // 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_));
+  EXPECT_CALL(*continue_window_, Hide())
+      .Times(AnyNumber());
+  EXPECT_CALL(*disconnect_window_, Hide())
+      .Times(AnyNumber());
   SimulateClientConnection(0, false);
-  RemoveClientSession();
+  context_.network_message_loop()->PostTask(
+      FROM_HERE, base::Bind(&ChromotingHostTest::RemoveClientSession,
+                            base::Unretained(this)));
+  PostQuitTask(&message_loop_);
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, CurtainModeFailSecond) {
   host_->Start();
 
   // When a video packet is received we connect the second mock
   // connection.
   {
     InSequence s;
     EXPECT_CALL(*curtain_, EnableCurtainMode(true))
         .WillOnce(QuitMainMessageLoop(&message_loop_));
-    EXPECT_CALL(*disconnect_window_, Show(_, _))
-        .Times(0);
+    EXPECT_CALL(*local_input_monitor_, Start(_))
+        .Times(1);
+    EXPECT_CALL(*disconnect_window_, Show(_, "user@domain"))
+        .Times(1);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .WillOnce(DoAll(
             InvokeWithoutArgs(
                 CreateFunctor(
                     this,
                     &ChromotingHostTest::SimulateClientConnection, 1, false)),
             RunDoneTask()))
         .RetiresOnSaturation();
     // Check that the second connection does not affect curtain mode.
     EXPECT_CALL(*curtain_, EnableCurtainMode(_))
@@ skipping 33 matching lines @@
         .Times(1)
         .InSequence(s2);
     EXPECT_CALL(video_stub_, ProcessVideoPacket(_, _))
         .InSequence(s1, s2)
         .WillOnce(DoAll(
             InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost),
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(*connection_.get(), Disconnect())
         .InSequence(s1, s2)
+        .WillOnce(InvokeWithoutArgs(
+            this, &ChromotingHostTest::RemoveClientSession))
         .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