Move code in src/remoting to the new callbacks.

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 153 matching lines @@
         (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::OnAuthenticationComplete,
+                                client.get()));
     }
   }
 
   // Helper method to remove a client connection from ChromotingHost.
   void RemoveClientConnection() {
     context_.network_message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(host_.get(),
-                          &ChromotingHost::OnClientDisconnected,
-                          connection_));
+        FROM_HERE, base::Bind(&ChromotingHost::OnClientDisconnected,
+                              host_.get(), 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_));
+    host_->Shutdown(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 18 matching lines @@
   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(
-          host_.get(), &ChromotingHost::Shutdown,
-          NewRunnableFunction(&PostQuitTask, &message_loop_)));
+      FROM_HERE, base::Bind(
+          &ChromotingHost::Shutdown, host_.get(),
+          base::Bind(&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.
   {
     InSequence s;
@@ skipping 211 matching lines @@
         .Times(1)
         .InSequence(s2);
   }
   SimulateClientConnection(0, true);
   message_loop_.Run();
   host_->set_it2me(false);
   EXPECT_THAT(curtain_activated, false);
 }
 
 }  // namespace remoting