Refactor the guts of ResourceDispatcherHostImpl into a new class named

content/browser/renderer_host/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/renderer_host/throttling_resource_handler.h"
 
-#include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/resource_response.h"
 
 namespace content {
 
 ThrottlingResourceHandler::ThrottlingResourceHandler(
-    ResourceDispatcherHostImpl* host,
     scoped_ptr<ResourceHandler> next_handler,
     int child_id,
     int request_id,
     ScopedVector<ResourceThrottle> throttles)
     : LayeredResourceHandler(next_handler.Pass()),
       deferred_stage_(DEFERRED_NONE),
-      host_(host),
       child_id_(child_id),
       request_id_(request_id),
       throttles_(throttles.Pass()),
       index_(0) {
   for (size_t i = 0; i < throttles_.size(); ++i)
     throttles_[i]->set_controller(this);
 }
 
 ThrottlingResourceHandler::~ThrottlingResourceHandler() {
 }
@@ skipping 57 matching lines @@
       return true;  // Do not cancel.
     }
   }
 
   index_ = 0;  // Reset for next time.
 
   return next_handler_->OnResponseStarted(request_id, response, defer);
 }
 
 void ThrottlingResourceHandler::Cancel() {
-  host_->CancelRequest(child_id_, request_id_, false);
+  controller()->Cancel();
 }
 
 void ThrottlingResourceHandler::Resume() {
   switch (deferred_stage_) {
     case DEFERRED_NONE:
       NOTREACHED();
       break;
     case DEFERRED_START:
       ResumeStart();
       break;
     case DEFERRED_REDIRECT:
       ResumeRedirect();
       break;
     case DEFERRED_RESPONSE:
       ResumeResponse();
       break;
   }
   deferred_stage_ = DEFERRED_NONE;
 }
 
 void ThrottlingResourceHandler::ResumeStart() {
   GURL url = deferred_url_;
   deferred_url_ = GURL();
 
   bool defer = false;
   if (!OnWillStart(request_id_, url, &defer)) {
-    Cancel();
+    controller()->Cancel();
   } else if (!defer) {
-    host_->StartDeferredRequest(child_id_, request_id_);
+    controller()->Resume();
   }
 }
 
 void ThrottlingResourceHandler::ResumeRedirect() {
   GURL new_url = deferred_url_;
   deferred_url_ = GURL();
   scoped_refptr<ResourceResponse> response;
   deferred_response_.swap(response);
 
   bool defer = false;
   if (!OnRequestRedirected(request_id_, new_url, response, &defer)) {
-    Cancel();
+    controller()->Cancel();
   } else if (!defer) {
-    host_->FollowDeferredRedirect(child_id_, request_id_, false, GURL());
+    controller()->Resume();
   }
 }
 
 void ThrottlingResourceHandler::ResumeResponse() {
   scoped_refptr<ResourceResponse> response;
   deferred_response_.swap(response);
 
   bool defer = false;
   if (!OnResponseStarted(request_id_, response, &defer)) {
-    Cancel();
+    controller()->Cancel();
   } else if (!defer) {
-    host_->ResumeDeferredRequest(child_id_, request_id_);
+    controller()->Resume();
   }
 }
 
 }  // namespace content