Switch content/browser/debugger to base::Bind

content/browser/debugger/worker_devtools_manager.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 "content/browser/debugger/worker_devtools_manager.h"
 
 #include <list>
 #include <map>
 
-#include "base/tuple.h"
+#include "base/bind.h"
 #include "content/browser/debugger/devtools_agent_host.h"
 #include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/debugger/worker_devtools_message_filter.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/browser/worker_host/worker_service.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 67 matching lines @@
 
 class WorkerDevToolsManager::WorkerDevToolsAgentHost
     : public DevToolsAgentHost {
  public:
   explicit WorkerDevToolsAgentHost(WorkerId worker_id)
       : worker_id_(worker_id) {
     AgentHosts::Add(worker_id, this);
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableFunction(
+        base::Bind(
             &RegisterAgent,
             worker_id.first,
             worker_id.second));
   }
 
   void WorkerDestroyed() {
     NotifyCloseListener();
     delete this;
   }
 
@@ skipping 14 matching lines @@
       int worker_route_id,
       const IPC::Message& message) {
     WorkerDevToolsManager::GetInstance()->ForwardToWorkerDevToolsAgent(
         worker_process_id, worker_route_id, message);
   }
 
   // DevToolsAgentHost implementation.
   virtual void SendMessageToAgent(IPC::Message* message) OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableFunction(
+        base::Bind(
             &WorkerDevToolsAgentHost::ForwardToWorkerDevToolsAgent,
             worker_id_.first,
             worker_id_.second,
             *message));
   }
   virtual void NotifyClientClosing() OVERRIDE {}
   virtual int GetRenderProcessId() OVERRIDE { return -1; }
 
   WorkerId worker_id_;
 
@@ skipping 48 matching lines @@
         agent);
     worker_id_to_cookie_.erase(it);
     if (worker_id_to_cookie_.empty())
       delete this;
     return true;
   }
 
   static void RemovePendingWorkerData(WorkerId id) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableFunction(RemoveInspectedWorkerDataOnIOThread, id));
+        base::Bind(RemoveInspectedWorkerDataOnIOThread, id));
   }
 
   static void RemoveInspectedWorkerDataOnIOThread(WorkerId id) {
     WorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(id);
   }
 
   static DetachedClientHosts* instance_;
   typedef std::map<WorkerId, int> WorkerIdToCookieMap;
   WorkerIdToCookieMap worker_id_to_cookie_;
 };
@@ skipping 77 matching lines @@
     return;
 
   WorkerId worker_id(worker->id(), worker_route_id);
   terminated_workers_.push_back(TerminatedInspectedWorker(
       worker_id,
       it->worker_url,
       it->worker_name));
   inspected_workers_.erase(it);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
-          DetachedClientHosts::WorkerDestroyed,
-          worker_id));
+      base::Bind(DetachedClientHosts::WorkerDestroyed, worker_id));
 }
 
 void WorkerDevToolsManager::WorkerContextStarted(WorkerProcessHost* process,
                                                  int worker_route_id) {
   WorkerId new_worker_id(process->id(), worker_route_id);
   PausedWorkers::iterator it = paused_workers_.find(new_worker_id);
   if (it == paused_workers_.end())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           DetachedClientHosts::WorkerReloaded,
           it->second,
           new_worker_id));
   paused_workers_.erase(it);
 }
 
 void WorkerDevToolsManager::RemoveInspectedWorkerData(
     const WorkerId& id) {
   for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
        it != terminated_workers_.end(); ++it) {
@@ skipping 57 matching lines @@
     int worker_process_id,
     int worker_route_id,
     const IPC::Message& message) {
   if (FindInspectedWorker(worker_process_id, worker_route_id) ==
           inspected_workers_.end()) {
       NOTREACHED();
       return;
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           ForwardToDevToolsClientOnUIThread,
           worker_process_id,
           worker_route_id,
           message));
 }
 
 void WorkerDevToolsManager::SaveAgentRuntimeState(int worker_process_id,
                                                   int worker_route_id,
                                                   const std::string& state) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           SaveAgentRuntimeStateOnUIThread,
           worker_process_id,
           worker_route_id,
           state));
 }
 
 void WorkerDevToolsManager::ForwardToWorkerDevToolsAgent(
     int worker_process_id,
     int worker_route_id,
     const IPC::Message& message) {
@@ skipping 32 matching lines @@
     return;
   DevToolsManager::GetInstance()->SaveAgentRuntimeState(agent_host, state);
 }
 
 // static
 void WorkerDevToolsManager::NotifyWorkerDestroyedOnIOThread(
     int worker_process_id,
     int worker_route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           &WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread,
           worker_process_id,
           worker_route_id));
 }
 
 // static
 void WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread(
     int worker_process_id,
     int worker_route_id) {
   WorkerDevToolsAgentHost* host =
       AgentHosts::GetAgentHost(WorkerId(worker_process_id, worker_route_id));
   if (host)
     host->WorkerDestroyed();
 }
 
 // static
 void WorkerDevToolsManager::SendResumeToWorker(const WorkerId& id) {
   if (WorkerProcessHost* process = FindWorkerProcess(id.first))
     process->Send(new DevToolsAgentMsg_ResumeWorkerContext(id.second));
 }