Move code in src/remoting to the new callbacks.

remoting/host/chromoting_host.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 "remoting/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
@@ skipping 86 matching lines @@
   }
 
   signal_strategy_.reset(
       new XmppSignalStrategy(context_->jingle_thread(), xmpp_login,
                              xmpp_auth_token,
                              xmpp_auth_service));
   signal_strategy_->Init(this);
 }
 
 // This method is called when we need to destroy the host process.
-void ChromotingHost::Shutdown(Task* shutdown_task) {
+void ChromotingHost::Shutdown(const base::Closure& shutdown_task) {
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingHost::Shutdown, this, shutdown_task));
     return;
   }
 
   // No-op if this object is not started yet.
   {
     base::AutoLock auto_lock(lock_);
     if (state_ == kInitial || state_ == kStopped) {
       // Nothing to do if we are not started.
       state_ = kStopped;
       context_->main_message_loop()->PostTask(FROM_HERE, shutdown_task);
       return;
     }
-    if (shutdown_task)
+    if (!shutdown_task.is_null())
       shutdown_tasks_.push_back(shutdown_task);
     if (state_ == kStopping)
       return;
     state_ = kStopping;
   }
 
   // Disconnect all of the clients, implicitly stopping the ScreenRecorder.
   while (!clients_.empty()) {
     OnClientDisconnected(clients_.front()->connection());
   }
@@ skipping 121 matching lines @@
     }
     return;
   }
 
   // If we are running Me2Mom and already have an authenticated client then
   // one of the connections may be an attacker, so both are suspect.
   if (is_it2me_ && AuthenticatedClientsCount() > 0) {
     *response = protocol::SessionManager::DECLINE;
 
     // Close existing sessions and shutdown the host.
-    Shutdown(NULL);
+    Shutdown(base::Closure());
     return;
   }
 
   // TODO(simonmorris): The resolution is set in the video stream now,
   // so it doesn't need to be set here.
   *protocol_config_->mutable_initial_resolution() =
       protocol::ScreenResolution(2048, 2048);
   // TODO(sergeyu): Respect resolution requested by the client if supported.
   protocol::SessionConfig config;
   if (!protocol_config_->Select(session->candidate_config(),
@@ skipping 47 matching lines @@
   }
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     client->get()->LocalMouseMoved(new_pos);
   }
 }
 
 void ChromotingHost::PauseSession(bool pause) {
   if (context_->main_message_loop() != MessageLoop::current()) {
     context_->main_message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this,
-                          &ChromotingHost::PauseSession,
-                          pause));
+        FROM_HERE, base::Bind(&ChromotingHost::PauseSession, this, pause));
     return;
   }
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     client->get()->set_awaiting_continue_approval(pause);
   }
   desktop_environment_->OnPause(pause);
 }
 
 void ChromotingHost::SetUiStrings(const UiStrings& ui_strings) {
@@ skipping 255 matching lines @@
   // Keep reference to |this|, so that we don't get destroyed while
   // sending notifications.
   scoped_refptr<ChromotingHost> self(this);
 
   // Notify observers.
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnShutdown();
   }
 
-  for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
+  for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
-    (*it)->Run();
-    delete *it;
+    it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting