Replace NewRunnableFunction with Callback in ChromeResourceDispatcherHostDelegate.

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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 "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_request_limiter.h"
@@ skipping 105 matching lines @@
     // If prefetch is disabled, kill the request.
     if (!ResourceDispatcherHost::is_prefetch_enabled())
       return false;
   }
 
   // Handle a PRERENDER motivated request. Very similar to rel=prefetch, these
   // rel=prerender requests instead launch an early render of the entire page.
   if (request_data.resource_type == ResourceType::PRERENDER) {
     if (prerender::PrerenderManager::IsPrerenderingPossible()) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          NewRunnableFunction(AddPrerenderOnUI,
-                              child_id,
-                              route_id,
-                              request_data.url,
-                              referrer));
+          base::Bind(&AddPrerenderOnUI,
+                     child_id,
+                     route_id,
+                     request_data.url,
+                     referrer));
     }
     // Prerendering or not, this request should be aborted.
     return false;
   }
 
   // Abort any prerenders that spawn requests that use invalid HTTP methods.
   if (prerender_tracker_->IsPrerenderingOnIOThread(child_id, route_id) &&
       !prerender::PrerenderManager::IsValidHttpMethod(request_data.method)) {
     prerender_tracker_->TryCancelOnIOThread(
         child_id, route_id,
@@ skipping 44 matching lines @@
       const content::ResourceContext& resource_context,
       net::URLRequest* request,
       int child_id,
       int route_id,
       int request_id,
       bool is_new_request,
       bool in_complete) {
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(&NotifyDownloadInitiatedOnUI, child_id, route_id));
+      base::Bind(&NotifyDownloadInitiatedOnUI, child_id, route_id));
 
   // If this isn't a new request, we've seen this before and added the safe
   // browsing resource handler already so no need to add it again. This code
   // path is only hit for requests initiated through the browser, and not the
   // web, so no need to add the throttling handler.
   if (is_new_request) {
 #if defined(ENABLE_SAFE_BROWSING)
     ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
         resource_context.GetUserData(NULL));
     if (!io_data->safe_browsing_enabled()->GetValue())
@@ skipping 71 matching lines @@
           InstantLoader::kInstantHeader, &instant_header_value) &&
       instant_header_value == InstantLoader::kInstantHeaderValue)
     return new InstantResourceDispatcherHostLoginDelegate;
   return CreateLoginPrompt(auth_info, request);
 }
 
 void ChromeResourceDispatcherHostDelegate::HandleExternalProtocol(
     const GURL& url, int child_id, int route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(
-          &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
+      base::Bind(&ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
 }
 
 #if defined(ENABLE_SAFE_BROWSING)
 ResourceHandler*
     ChromeResourceDispatcherHostDelegate::CreateSafeBrowsingResourceHandler(
         ResourceHandler* handler, int child_id, int route_id,
         bool subresource) {
   return SafeBrowsingResourceHandler::Create(
       handler, child_id, route_id, subresource, safe_browsing_,
       resource_dispatcher_host_);
@@ skipping 31 matching lines @@
   AutoLoginPrompter::ShowInfoBarIfPossible(request, info->child_id(),
                                            info->route_id());
 }
 
 void ChromeResourceDispatcherHostDelegate::OnRequestRedirected(
     net::URLRequest* request,
     ResourceResponse* response,
     ResourceMessageFilter* filter) {
   LoadTimingObserver::PopulateTimingInfo(request, response);
 }