Switch content/browser/debugger to base::Bind

content/browser/debugger/devtools_http_protocol_handler.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/devtools_http_protocol_handler.h"
 
 #include <utility>
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 25 matching lines @@
       : server_(server),
         connection_id_(connection_id) {
   }
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
   virtual void InspectedTabClosing() {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableMethod(server_,
-                          &net::HttpServer::Close,
-                          connection_id_));
+        base::Bind(&net::HttpServer::Close, server_, connection_id_));
   }
 
   virtual void SendMessageToClient(const IPC::Message& msg) {
     IPC_BEGIN_MESSAGE_MAP(DevToolsClientHostImpl, msg)
       IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
                           OnDispatchOnInspectorFrontend);
       IPC_MESSAGE_UNHANDLED_ERROR()
     IPC_END_MESSAGE_MAP()
   }
 
   virtual void TabReplaced(TabContents* new_tab) {
   }
 
   void NotifyCloseListener() {
     DevToolsClientHost::NotifyCloseListener();
   }
  private:
   // Message handling routines
   void OnDispatchOnInspectorFrontend(const std::string& data) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableMethod(server_,
-                          &net::HttpServer::SendOverWebSocket,
-                          connection_id_,
-                          data));
+        base::Bind(&net::HttpServer::SendOverWebSocket,
+                   server_,
+                   connection_id_,
+                   data));
   }
 
   virtual void FrameNavigating(const std::string& url) {}
   net::HttpServer* server_;
   int connection_id_;
 };
 
 static int next_id = 1;
 
 class TabContentsIDHelper : public TabContentsObserver {
@@ skipping 65 matching lines @@
 }
 
 DevToolsHttpProtocolHandler::~DevToolsHttpProtocolHandler() {
   // Stop() must be called prior to this being called
   DCHECK(server_.get() == NULL);
 }
 
 void DevToolsHttpProtocolHandler::Start() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &DevToolsHttpProtocolHandler::Init));
+      base::Bind(&DevToolsHttpProtocolHandler::Init, this));
 }
 
 void DevToolsHttpProtocolHandler::Stop() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &DevToolsHttpProtocolHandler::Teardown));
+      base::Bind(&DevToolsHttpProtocolHandler::Teardown, this));
 }
 
 void DevToolsHttpProtocolHandler::OnHttpRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   if (info.path == "/json") {
     // Pages discovery json request.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        NewRunnableMethod(this,
-                          &DevToolsHttpProtocolHandler::OnJsonRequestUI,
-                          connection_id,
-                          info));
+        base::Bind(&DevToolsHttpProtocolHandler::OnJsonRequestUI,
+                   this,
+                   connection_id,
+                   info));
     return;
   }
 
   // Proxy static files from chrome-devtools://devtools/*.
   net::URLRequestContext* request_context = delegate_->GetURLRequestContext();
   if (!request_context) {
     server_->Send404(connection_id);
     return;
   }
 
@@ skipping 18 matching lines @@
   request->set_context(request_context);
   request->Start();
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableMethod(
+      base::Bind(
+          &DevToolsHttpProtocolHandler::OnWebSocketRequestUI,
           this,
-          &DevToolsHttpProtocolHandler::OnWebSocketRequestUI,
           connection_id,
           request));
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketMessage(
     int connection_id,
     const std::string& data) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableMethod(
+      base::Bind(
+          &DevToolsHttpProtocolHandler::OnWebSocketMessageUI,
           this,
-          &DevToolsHttpProtocolHandler::OnWebSocketMessageUI,
           connection_id,
           data));
 }
 
 void DevToolsHttpProtocolHandler::OnClose(int connection_id) {
   ConnectionToRequestsMap::iterator it =
       connection_to_requests_io_.find(connection_id);
   if (it != connection_to_requests_io_.end()) {
     // Dispose delegating socket.
     for (std::set<net::URLRequest*>::iterator it2 = it->second.begin();
          it2 != it->second.end(); ++it2) {
       net::URLRequest* request = *it2;
       request->Cancel();
       request_to_connection_io_.erase(request);
       request_to_buffer_io_.erase(request);
       delete request;
     }
     connection_to_requests_io_.erase(connection_id);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableMethod(
+      base::Bind(
+          &DevToolsHttpProtocolHandler::OnCloseUI,
           this,
-          &DevToolsHttpProtocolHandler::OnCloseUI,
           connection_id));
 }
 
 struct PageInfo
 {
   int id;
   std::string url;
   bool attached;
   std::string title;
   std::string thumbnail_url;
@@ skipping 242 matching lines @@
   it2->second.erase(request);
   request_to_buffer_io_.erase(request);
   delete request;
 }
 
 void DevToolsHttpProtocolHandler::Send200(int connection_id,
                                           const std::string& data,
                                           const std::string& mime_type) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(server_.get(),
-                        &net::HttpServer::Send200,
-                        connection_id,
-                        data,
-                        mime_type));
+      base::Bind(&net::HttpServer::Send200,
+                 server_.get(),
+                 connection_id,
+                 data,
+                 mime_type));
 }
 
 void DevToolsHttpProtocolHandler::Send404(int connection_id) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(server_.get(),
-                        &net::HttpServer::Send404,
-                        connection_id));
+      base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
 }
 
 void DevToolsHttpProtocolHandler::Send500(int connection_id,
                                           const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(server_.get(),
-                        &net::HttpServer::Send500,
-                        connection_id,
-                        message));
+      base::Bind(&net::HttpServer::Send500, server_.get(), connection_id,
+                 message));
 }
 
 void DevToolsHttpProtocolHandler::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(server_.get(),
-                        &net::HttpServer::AcceptWebSocket,
-                        connection_id,
-                        request));
+      base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
+                 connection_id, request));
 }