content/browser/loader/throttling_resource_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/loader/throttling_resource_handler.h"
   6
   7 #include "content/browser/loader/resource_request_info_impl.h"
   8 #include "content/public/browser/resource_throttle.h"
   9 #include "content/public/common/resource_response.h"
  10 #include "net/url_request/url_request.h"
  11
  12 namespace content {
  13
  14 ThrottlingResourceHandler::ThrottlingResourceHandler(
  15     scoped_ptr<ResourceHandler> next_handler,
  16     net::URLRequest* request,
  17     ScopedVector<ResourceThrottle> throttles)
  18     : LayeredResourceHandler(request, next_handler.Pass()),
  19       deferred_stage_(DEFERRED_NONE),
  20       throttles_(throttles.Pass()),
  21       next_index_(0),
  22       cancelled_by_resource_throttle_(false) {
  23   for (size_t i = 0; i < throttles_.size(); ++i) {
  24     throttles_[i]->set_controller(this);
  25     // Throttles must have a name, as otherwise, bugs where a throttle fails
  26     // to resume a request can be very difficult to debug.
  27     DCHECK(throttles_[i]->GetNameForLogging());
  28   }
  29 }
  30
  31 ThrottlingResourceHandler::~ThrottlingResourceHandler() {
  32 }
  33
  34 bool ThrottlingResourceHandler::OnRequestRedirected(
  35     const net::RedirectInfo& redirect_info,
  36     ResourceResponse* response,
  37     bool* defer) {
  38   DCHECK(!cancelled_by_resource_throttle_);
  39
  40   *defer = false;
  41   while (next_index_ < throttles_.size()) {
  42     int index = next_index_;
  43     throttles_[index]->WillRedirectRequest(redirect_info.new_url, defer);
  44     next_index_++;
  45     if (cancelled_by_resource_throttle_)
  46       return false;
  47     if (*defer) {
  48       OnRequestDefered(index);
  49       deferred_stage_ = DEFERRED_REDIRECT;
  50       deferred_redirect_ = redirect_info;
  51       deferred_response_ = response;
  52       return true;  // Do not cancel.
  53     }
  54   }
  55
  56   next_index_ = 0;  // Reset for next time.
  57
  58   return next_handler_->OnRequestRedirected(redirect_info, response, defer);
  59 }
  60
  61 bool ThrottlingResourceHandler::OnWillStart(const GURL& url, bool* defer) {
  62   DCHECK(!cancelled_by_resource_throttle_);
  63
  64   *defer = false;
  65   while (next_index_ < throttles_.size()) {
  66     int index = next_index_;
  67     throttles_[index]->WillStartRequest(defer);
  68     next_index_++;
  69     if (cancelled_by_resource_throttle_)
  70       return false;
  71     if (*defer) {
  72       OnRequestDefered(index);
  73       deferred_stage_ = DEFERRED_START;
  74       deferred_url_ = url;
  75       return true;  // Do not cancel.
  76     }
  77   }
  78
  79   next_index_ = 0;  // Reset for next time.
  80
  81   return next_handler_->OnWillStart(url, defer);
  82 }
  83
  84 bool ThrottlingResourceHandler::OnBeforeNetworkStart(const GURL& url,
  85                                                      bool* defer) {
  86   DCHECK(!cancelled_by_resource_throttle_);
  87
  88   *defer = false;
  89   while (next_index_ < throttles_.size()) {
  90     int index = next_index_;
  91     throttles_[index]->WillStartUsingNetwork(defer);
  92     next_index_++;
  93     if (cancelled_by_resource_throttle_)
  94       return false;
  95     if (*defer) {
  96       OnRequestDefered(index);
  97       deferred_stage_ = DEFERRED_NETWORK_START;
  98       deferred_url_ = url;
  99       return true;  // Do not cancel.
 100     }
 101   }
 102
 103   next_index_ = 0;  // Reset for next time.
 104
 105   return next_handler_->OnBeforeNetworkStart(url, defer);
 106 }
 107
 108 bool ThrottlingResourceHandler::OnResponseStarted(ResourceResponse* response,
 109                                                   bool* defer) {
 110   DCHECK(!cancelled_by_resource_throttle_);
 111
 112   while (next_index_ < throttles_.size()) {
 113     int index = next_index_;
 114     throttles_[index]->WillProcessResponse(defer);
 115     next_index_++;
 116     if (cancelled_by_resource_throttle_)
 117       return false;
 118     if (*defer) {
 119       OnRequestDefered(index);
 120       deferred_stage_ = DEFERRED_RESPONSE;
 121       deferred_response_ = response;
 122       return true;  // Do not cancel.
 123     }
 124   }
 125
 126   next_index_ = 0;  // Reset for next time.
 127
 128   return next_handler_->OnResponseStarted(response, defer);
 129 }
 130
 131 void ThrottlingResourceHandler::Cancel() {
 132   cancelled_by_resource_throttle_ = true;
 133   controller()->Cancel();
 134 }
 135
 136 void ThrottlingResourceHandler::CancelAndIgnore() {
 137   cancelled_by_resource_throttle_ = true;
 138   controller()->CancelAndIgnore();
 139 }
 140
 141 void ThrottlingResourceHandler::CancelWithError(int error_code) {
 142   cancelled_by_resource_throttle_ = true;
 143   controller()->CancelWithError(error_code);
 144 }
 145
 146 void ThrottlingResourceHandler::Resume() {
 147   DCHECK(!cancelled_by_resource_throttle_);
 148
 149   DeferredStage last_deferred_stage = deferred_stage_;
 150   deferred_stage_ = DEFERRED_NONE;
 151   // Clear information about the throttle that delayed the request.
 152   request()->LogUnblocked();
 153   switch (last_deferred_stage) {
 154     case DEFERRED_NONE:
 155       NOTREACHED();
 156       break;
 157     case DEFERRED_START:
 158       ResumeStart();
 159       break;
 160     case DEFERRED_NETWORK_START:
 161       ResumeNetworkStart();
 162       break;
 163     case DEFERRED_REDIRECT:
 164       ResumeRedirect();
 165       break;
 166     case DEFERRED_RESPONSE:
 167       ResumeResponse();
 168       break;
 169   }
 170 }
 171
 172 void ThrottlingResourceHandler::ResumeStart() {
 173   DCHECK(!cancelled_by_resource_throttle_);
 174
 175   GURL url = deferred_url_;
 176   deferred_url_ = GURL();
 177
 178   bool defer = false;
 179   if (!OnWillStart(url, &defer)) {
 180     controller()->Cancel();
 181   } else if (!defer) {
 182     controller()->Resume();
 183   }
 184 }
 185
 186 void ThrottlingResourceHandler::ResumeNetworkStart() {
 187   DCHECK(!cancelled_by_resource_throttle_);
 188
 189   GURL url = deferred_url_;
 190   deferred_url_ = GURL();
 191
 192   bool defer = false;
 193   if (!OnBeforeNetworkStart(url, &defer)) {
 194     controller()->Cancel();
 195   } else if (!defer) {
 196     controller()->Resume();
 197   }
 198 }
 199
 200 void ThrottlingResourceHandler::ResumeRedirect() {
 201   DCHECK(!cancelled_by_resource_throttle_);
 202
 203   net::RedirectInfo redirect_info = deferred_redirect_;
 204   deferred_redirect_ = net::RedirectInfo();
 205   scoped_refptr<ResourceResponse> response;
 206   deferred_response_.swap(response);
 207
 208   bool defer = false;
 209   if (!OnRequestRedirected(redirect_info, response.get(), &defer)) {
 210     controller()->Cancel();
 211   } else if (!defer) {
 212     controller()->Resume();
 213   }
 214 }
 215
 216 void ThrottlingResourceHandler::ResumeResponse() {
 217   DCHECK(!cancelled_by_resource_throttle_);
 218
 219   scoped_refptr<ResourceResponse> response;
 220   deferred_response_.swap(response);
 221
 222   bool defer = false;
 223   if (!OnResponseStarted(response.get(), &defer)) {
 224     controller()->Cancel();
 225   } else if (!defer) {
 226     controller()->Resume();
 227   }
 228 }
 229
 230 void ThrottlingResourceHandler::OnRequestDefered(int throttle_index) {
 231   request()->LogBlockedBy(throttles_[throttle_index]->GetNameForLogging());
 232 }
 233
 234 }  // namespace content