Adds the new URLRequest::OnBeforeNetworkStart hook to the

content/browser/loader/throttling_resource_handler.cc

 // Copyright (c) 2012 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/loader/throttling_resource_handler.h"
 
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/resource_response.h"
 #include "net/url_request/url_request.h"
@@ skipping 66 matching lines @@
       deferred_url_ = url;
       return true;  // Do not cancel.
     }
   }
 
   next_index_ = 0;  // Reset for next time.
 
   return next_handler_->OnWillStart(request_id, url, defer);
 }
 
+bool ThrottlingResourceHandler::OnBeforeNetworkStart(int request_id,
+                                                     const GURL& url,
+                                                     bool* defer) {
+  DCHECK(!cancelled_by_resource_throttle_);
+
+  *defer = false;
+  while (next_index_ < throttles_.size()) {
+    int index = next_index_;
+    throttles_[index]->OnBeforeNetworkStart(defer);
+    next_index_++;
+    if (cancelled_by_resource_throttle_)
+      return false;
+    if (*defer) {
+      OnRequestDefered(index);
+      deferred_stage_ = DEFERRED_NETWORK_START;
+      deferred_url_ = url;
+      return true;  // Do not cancel.
+    }
+  }
+
+  next_index_ = 0;  // Reset for next time.
+
+  return next_handler_->OnBeforeNetworkStart(request_id, url, defer);
+}
+
 bool ThrottlingResourceHandler::OnResponseStarted(int request_id,
                                                   ResourceResponse* response,
                                                   bool* defer) {
   DCHECK(!cancelled_by_resource_throttle_);
 
   while (next_index_ < throttles_.size()) {
     int index = next_index_;
     throttles_[index]->WillProcessResponse(defer);
     next_index_++;
     if (cancelled_by_resource_throttle_)
@@ skipping 33 matching lines @@
   deferred_stage_ = DEFERRED_NONE;
   // Clear information about the throttle that delayed the request.
   request()->LogUnblocked();
   switch (last_deferred_stage) {
     case DEFERRED_NONE:
       NOTREACHED();
       break;
     case DEFERRED_START:
       ResumeStart();
       break;
+    case DEFERRED_NETWORK_START:
+      ResumeNetworkStart();
+      break;
     case DEFERRED_REDIRECT:
       ResumeRedirect();
       break;
     case DEFERRED_RESPONSE:
       ResumeResponse();
       break;
   }
 }
 
 void ThrottlingResourceHandler::ResumeStart() {
   DCHECK(!cancelled_by_resource_throttle_);
 
   GURL url = deferred_url_;
   deferred_url_ = GURL();
 
   bool defer = false;
   if (!OnWillStart(GetRequestID(), url, &defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
+void ThrottlingResourceHandler::ResumeNetworkStart() {
+  DCHECK(!cancelled_by_resource_throttle_);
+
+  GURL url = deferred_url_;
+  deferred_url_ = GURL();
+
+  bool defer = false;
+  if (!OnBeforeNetworkStart(GetRequestID(), url, &defer)) {
+    controller()->Cancel();
+  } else if (!defer) {
+    controller()->Resume();
+  }
+}
+
 void ThrottlingResourceHandler::ResumeRedirect() {
   DCHECK(!cancelled_by_resource_throttle_);
 
   GURL new_url = deferred_url_;
   deferred_url_ = GURL();
   scoped_refptr<ResourceResponse> response;
   deferred_response_.swap(response);
 
   bool defer = false;
   if (!OnRequestRedirected(GetRequestID(), new_url, response.get(), &defer)) {
@@ skipping 15 matching lines @@
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 void ThrottlingResourceHandler::OnRequestDefered(int throttle_index) {
   request()->LogBlockedBy(throttles_[throttle_index]->GetNameForLogging());
 }
 
 }  // namespace content