base::Bind: Convert net::NetworkDelegate.

chrome/browser/extensions/extension_webrequest_api.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/extensions/extension_webrequest_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ skipping 329 matching lines @@
   EventTypes event;
 
   // The number of event handlers that we are awaiting a response from.
   int num_handlers_blocking;
 
   // Pointer to NetLog to report significant changes to the request for
   // debugging.
   const net::BoundNetLog* net_log;
 
   // The callback to call when we get a response from all event handlers.
-  net::OldCompletionCallback* callback;
+  net::CompletionCallback callback;
 
   // If non-empty, this contains the new URL that the request will redirect to.
   // Only valid for OnBeforeRequest.
   GURL* new_url;
 
   // The request headers that will be issued along with this request. Only valid
   // for OnBeforeSendHeaders.
   net::HttpRequestHeaders* request_headers;
 
   // The response headers that were received from the server. Only valid for
@@ skipping 17 matching lines @@
   base::Time blocking_time;
 
   // Changes requested by extensions.
   helpers::EventResponseDeltas response_deltas;
 
   BlockedRequest()
       : request(NULL),
         event(kInvalidEvent),
         num_handlers_blocking(0),
         net_log(NULL),
-        callback(NULL),
         new_url(NULL),
         request_headers(NULL),
         override_response_headers(NULL),
         auth_credentials(NULL) {}
 };
 
 bool ExtensionWebRequestEventRouter::RequestFilter::InitFromValue(
     const DictionaryValue& value, std::string* error) {
   for (DictionaryValue::key_iterator key = value.begin_keys();
        key != value.end_keys(); ++key) {
@@ skipping 97 matching lines @@
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    net::OldCompletionCallback* callback,
+    const net::CompletionCallback& callback,
     GURL* new_url) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (!profile)
     return net::OK;
 
   if (IsPageLoad(request))
     NotifyPageLoad();
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
@@ skipping 25 matching lines @@
     blocked_requests_[request->identifier()].net_log = &request->net_log();
     return net::ERR_IO_PENDING;
   }
   return net::OK;
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    net::OldCompletionCallback* callback,
+    const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (!profile)
     return net::OK;
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders))
     return net::OK;
@@ skipping 53 matching lines @@
     dict->Set(keys::kRequestHeadersKey, GetRequestHeadersList(headers));
   args.Append(dict);
 
   DispatchEvent(profile, request, listeners, args);
 }
 
 int ExtensionWebRequestEventRouter::OnHeadersReceived(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
-    net::OldCompletionCallback* callback,
+    const net::CompletionCallback& callback,
     net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   if (!profile)
     return net::OK;
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
@@ skipping 617 matching lines @@
     std::set<std::string> conflicting_extensions;
     helpers::EventLogEntries event_log_entries;
 
     bool canceled = false;
     helpers::MergeCancelOfResponses(
         blocked_request.response_deltas,
         &canceled,
         &event_log_entries);
 
     if (blocked_request.event == kOnBeforeRequest) {
-      CHECK(blocked_request.callback);
+      CHECK(!blocked_request.callback.is_null());
       helpers::MergeOnBeforeRequestResponses(
           blocked_request.response_deltas,
           blocked_request.new_url,
           &conflicting_extensions,
           &event_log_entries);
     } else if (blocked_request.event == kOnBeforeSendHeaders) {
-      CHECK(blocked_request.callback);
+      CHECK(!blocked_request.callback.is_null());
       helpers::MergeOnBeforeSendHeadersResponses(
           blocked_request.response_deltas,
           blocked_request.request_headers,
           &conflicting_extensions,
           &event_log_entries);
     } else if (blocked_request.event == kOnHeadersReceived) {
-      CHECK(blocked_request.callback);
+      CHECK(!blocked_request.callback.is_null());
       helpers::MergeOnHeadersReceivedResponses(
           blocked_request.response_deltas,
           blocked_request.original_response_headers.get(),
           blocked_request.override_response_headers,
           &conflicting_extensions,
           &event_log_entries);
     } else if (blocked_request.event == kOnAuthRequired) {
-      CHECK(!blocked_request.callback);
+      CHECK(blocked_request.callback.is_null());
       CHECK(!blocked_request.auth_callback.is_null());
       credentials_set = helpers::MergeOnAuthRequiredResponses(
          blocked_request.response_deltas,
          blocked_request.auth_credentials,
          &conflicting_extensions,
          &event_log_entries);
     } else {
       NOTREACHED();
     }
 
@@ skipping 12 matching lines @@
                      ExtensionWarningSet::kNetworkConflict));
     }
 
     if (canceled) {
       request_time_tracker_->SetRequestCanceled(request_id);
     } else if (blocked_request.new_url &&
                !blocked_request.new_url->is_empty()) {
       request_time_tracker_->SetRequestRedirected(request_id);
     }
 
-    if (blocked_request.callback) {
+    if (!blocked_request.callback.is_null()) {
       // This triggers onErrorOccurred.
       int rv = canceled ? net::ERR_BLOCKED_BY_CLIENT : net::OK;
-      net::OldCompletionCallback* callback = blocked_request.callback;
+      net::CompletionCallback callback = blocked_request.callback;
       // Ensure that request is removed before callback because the callback
       // might trigger the next event.
       blocked_requests_.erase(request_id);
-      callback->Run(rv);
+      callback.Run(rv);
     } else if (!blocked_request.auth_callback.is_null()) {
       net::NetworkDelegate::AuthRequiredResponse response =
           net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
       if (canceled) {
         response = net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH;
       } else if (credentials_set) {
         response = net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH;
       }
       net::NetworkDelegate::AuthCallback callback =
           blocked_request.auth_callback;
@@ skipping 325 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }