Introduce a delegate to avoid hardcoding "chrome-extension" in net/.

net/url_request/url_request_throttler_entry.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 "net/url_request/url_request_throttler_entry.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_log.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_throttler_header_interface.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace net {
 
 const int URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs = 2000;
 const int URLRequestThrottlerEntry::kDefaultMaxSendThreshold = 20;
 
 // This set of back-off parameters will (at maximum values, i.e. without
 // the reduction caused by jitter) add 0-41% (distributed uniformly
@@ skipping 104 matching lines @@
 bool URLRequestThrottlerEntry::IsEntryOutdated() const {
   // This function is called by the URLRequestThrottlerManager to determine
   // whether entries should be discarded from its url_entries_ map.  We
   // want to ensure that it does not remove entries from the map while there
   // are clients (objects other than the manager) holding references to
   // the entry, otherwise separate clients could end up holding separate
   // entries for a request to the same URL, which is undesirable.  Therefore,
   // if an entry has more than one reference (the map will always hold one),
   // it should not be considered outdated.
   //
-  // TODO(joi): Once the manager is not a Singleton, revisit whether
-  // refcounting is needed at all.
+  // We considered whether to make URLRequestThrottlerEntry objects
+  // non-refcounted, but since any means of knowing whether they are
+  // currently in use by others than the manager would be more or less
+  // equivalent to a refcount, we kept them refcounted.
   if (!HasOneRef())
     return false;
 
   // If there are send events in the sliding window period, we still need this
   // entry.
   if (!send_log_.empty() &&
       send_log_.back() + sliding_window_period_ > ImplGetTimeNow()) {
     return false;
   }
 
   return GetBackoffEntry()->CanDiscard();
 }
 
 void URLRequestThrottlerEntry::DisableBackoffThrottling() {
   is_backoff_disabled_ = true;
 }
 
 void URLRequestThrottlerEntry::DetachManager() {
   manager_ = NULL;
 }
 
-bool URLRequestThrottlerEntry::ShouldRejectRequest(int load_flags) const {
+bool URLRequestThrottlerEntry::ShouldRejectRequest(
+    const URLRequest& request) const {
   bool reject_request = false;
-  if (!is_backoff_disabled_ && !ExplicitUserRequest(load_flags) &&
+  if (!is_backoff_disabled_ && !ExplicitUserRequest(request.load_flags()) &&
+      (!request.context() || !request.context()->network_delegate() ||
+       request.context()->network_delegate()->CanThrottleRequest(request)) &&
       GetBackoffEntry()->ShouldRejectRequest()) {
     int num_failures = GetBackoffEntry()->failure_count();
     int release_after_ms =
         GetBackoffEntry()->GetTimeUntilRelease().InMilliseconds();
 
     net_log_.AddEvent(
         NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
         make_scoped_refptr(
             new RejectedRequestParameters(url_id_,
                                           num_failures,
@@ skipping 53 matching lines @@
   // return "now" so that retries are not delayed.
   if (is_backoff_disabled_)
     return ImplGetTimeNow();
 
   return GetBackoffEntry()->GetReleaseTime();
 }
 
 void URLRequestThrottlerEntry::UpdateWithResponse(
     const std::string& host,
     const URLRequestThrottlerHeaderInterface* response) {
-  int response_code = response->GetResponseCode();
-  HandleMetricsTracking(response_code);
-
-  if (IsConsideredError(response_code)) {
+  if (IsConsideredError(response->GetResponseCode())) {
     GetBackoffEntry()->InformOfRequest(false);
   } else {
     GetBackoffEntry()->InformOfRequest(true);
 
     std::string throttling_header = response->GetNormalizedValue(
         kExponentialThrottlingHeader);
     if (!throttling_header.empty())
       HandleThrottlingHeader(throttling_header, host);
   }
 }
@@ skipping 19 matching lines @@
 
 void URLRequestThrottlerEntry::Initialize() {
   sliding_window_release_time_ = base::TimeTicks::Now();
   backoff_policy_.num_errors_to_ignore = kDefaultNumErrorsToIgnore;
   backoff_policy_.initial_delay_ms = kDefaultInitialDelayMs;
   backoff_policy_.multiply_factor = kDefaultMultiplyFactor;
   backoff_policy_.jitter_factor = kDefaultJitterFactor;
   backoff_policy_.maximum_backoff_ms = kDefaultMaximumBackoffMs;
   backoff_policy_.entry_lifetime_ms = kDefaultEntryLifetimeMs;
   backoff_policy_.always_use_initial_delay = false;
-
-  // We pretend we just had a successful response so that we have a
-  // starting point to our tracking. This is called from the
-  // constructor so we do not use the virtual ImplGetTimeNow().
-  last_successful_response_time_ = base::TimeTicks::Now();
-  last_response_was_success_ = true;
 }
 
 bool URLRequestThrottlerEntry::IsConsideredError(int response_code) {
   // We throttle only for the status codes most likely to indicate the server
   // is failing because it is too busy or otherwise are likely to be
   // because of DDoS.
   //
   // 500 is the generic error when no better message is suitable, and
   //     as such does not necessarily indicate a temporary state, but
   //     other status codes cover most of the permanent error states.
@@ skipping 16 matching lines @@
   return base::TimeTicks::Now();
 }
 
 void URLRequestThrottlerEntry::HandleThrottlingHeader(
     const std::string& header_value,
     const std::string& host) {
   if (header_value == kExponentialThrottlingDisableValue) {
     DisableBackoffThrottling();
     if (manager_)
       manager_->AddToOptOutList(host);
-  } else {
-    // TODO(joi): Log this.
   }
 }
 
-void URLRequestThrottlerEntry::HandleMetricsTracking(int response_code) {
-  // Note that we are not interested in whether the code is considered
-  // an error for the backoff logic, but whether it is a 5xx error in
-  // general.  This is because here, we are tracking the apparent total
-  // downtime of a server.
-  if (response_code >= 500) {
-    last_response_was_success_ = false;
-  } else {
-    base::TimeTicks now = ImplGetTimeNow();
-    if (!last_response_was_success_) {
-      // We are transitioning from failure to success, so generate our stats.
-      base::TimeDelta down_time = now - last_successful_response_time_;
-      int failure_count = GetBackoffEntry()->failure_count();
-
-      UMA_HISTOGRAM_COUNTS("Throttling.FailureCountAtSuccess", failure_count);
-      UMA_HISTOGRAM_CUSTOM_TIMES(
-          "Throttling.PerceivedDowntime", down_time,
-          base::TimeDelta::FromMilliseconds(10),
-          base::TimeDelta::FromHours(6), 50);
-    }
-
-    last_successful_response_time_ = now;
-    last_response_was_success_ = true;
-  }
-}
-
 const BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() const {
   return &backoff_entry_;
 }
 
 BackoffEntry* URLRequestThrottlerEntry::GetBackoffEntry() {
   return &backoff_entry_;
 }
 
 // static
 bool URLRequestThrottlerEntry::ExplicitUserRequest(const int load_flags) {
   return (load_flags & LOAD_MAYBE_USER_GESTURE) != 0;
 }
 
 }  // namespace net