Convert NewRunnableFunction/NewRunnableMethod calls to use base::Bind().

content/browser/renderer_host/resource_dispatcher_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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 288 matching lines @@
 }  // namespace
 
 ResourceDispatcherHost::ResourceDispatcherHost(
     const ResourceQueue::DelegateSet& resource_queue_delegates)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           download_file_manager_(new DownloadFileManager(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           save_file_manager_(new SaveFileManager(this))),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(NULL),
       delegate_(NULL),
       allow_cross_origin_auth_prompt_(false) {
   resource_queue_.Initialize(resource_queue_delegates);
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 }
 
 ResourceDispatcherHost::~ResourceDispatcherHost() {
   AsyncResourceHandler::GlobalCleanup();
   STLDeleteValues(&pending_requests_);
 }
 
 void ResourceDispatcherHost::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   webkit_thread_->Initialize();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableFunction(&appcache::AppCacheInterceptor::EnsureRegistered));
+      base::Bind(&appcache::AppCacheInterceptor::EnsureRegistered));
 }
 
 void ResourceDispatcherHost::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, new ShutdownTask(this));
 }
 
 void ResourceDispatcherHost::SetRequestInfo(
     net::URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
@@ skipping 648 matching lines @@
     return;
   }
   info->set_pause_count(pause_count);
 
   VLOG(1) << "To pause (" << pause << "): " << i->second->url().spec();
 
   // If we're resuming, kick the request to start reading again. Run the read
   // asynchronously to avoid recursion problems.
   if (info->pause_count() == 0) {
     MessageLoop::current()->PostTask(FROM_HERE,
-        method_runner_.NewRunnableMethod(
-            &ResourceDispatcherHost::ResumeRequest, global_id));
+        base::Bind(
+            &ResourceDispatcherHost::ResumeRequest, weak_factory_.GetWeakPtr(),
+            global_id));
   }
 }
 
 int ResourceDispatcherHost::GetOutstandingRequestsMemoryCost(
     int child_id) const {
   OutstandingRequestsMemoryCostMap::const_iterator entry =
       outstanding_requests_memory_cost_map_.find(child_id);
   return (entry == outstanding_requests_memory_cost_map_.end()) ?
       0 : entry->second;
 }
@@ skipping 695 matching lines @@
         // This avoids a fast, large network request from monopolizing the IO
         // thread and starving other IO operations from running.
         VLOG(1) << "OnReadCompleted postponing: \""
                 << request->url().spec() << "\""
                 << " bytes_read = " << bytes_read;
         info->set_paused_read_bytes(bytes_read);
         info->set_is_paused(true);
         GlobalRequestID id(info->child_id(), info->request_id());
         MessageLoop::current()->PostTask(
             FROM_HERE,
-            method_runner_.NewRunnableMethod(
-                &ResourceDispatcherHost::ResumeRequest, id));
+            base::Bind(
+                &ResourceDispatcherHost::ResumeRequest,
+                weak_factory_.GetWeakPtr(), id));
         return;
       }
     }
   }
 
   if (PauseRequestIfNeeded(info)) {
     info->set_paused_read_bytes(bytes_read);
     VLOG(1) << "OnReadCompleted (CompleteRead) pausing: \""
             << request->url().spec() << "\""
             << " bytes_read = " << bytes_read;
@@ skipping 140 matching lines @@
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   ResourceRequestDetails* detail = new ResourceRequestDetails(
       request, GetCertID(request, child_id));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           &ResourceDispatcherHost::NotifyOnUI<ResourceRequestDetails>,
           static_cast<int>(content::NOTIFICATION_RESOURCE_RESPONSE_STARTED),
           render_process_id, render_view_id, detail));
 }
 
 void ResourceDispatcherHost::NotifyReceivedRedirect(net::URLRequest* request,
                                                     int child_id,
                                                     const GURL& new_url) {
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return;
 
   // Notify the observers on the UI thread.
   ResourceRedirectDetails* detail = new ResourceRedirectDetails(
       request, GetCertID(request, child_id), new_url);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
+      base::Bind(
           &ResourceDispatcherHost::NotifyOnUI<ResourceRedirectDetails>,
           static_cast<int>(content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT),
           render_process_id, render_view_id, detail));
 }
 
 template <class T>
 void ResourceDispatcherHost::NotifyOnUI(int type,
                                         int render_process_id,
                                         int render_view_id,
                                         T* detail) {
@@ skipping 246 matching lines @@
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }