Implement A/B experiment for anti-DDoS.

net/url_request/url_request_throttler_entry.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 "net/url_request/url_request_throttler_entry.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 181 matching lines @@
             new RejectedRequestParameters(url_id_,
                                           num_failures,
                                           release_after_ms)));
 
     reject_request = true;
   }
 
   int reject_count = reject_request ? 1 : 0;
   UMA_HISTOGRAM_ENUMERATION(
       "Throttling.RequestThrottled", reject_count, 2);
-  if (base::FieldTrialList::TrialExists("ThrottlingEnabled")) {
+  if (base::FieldTrialList::TrialExists("HttpThrottlingEnabled")) {
     UMA_HISTOGRAM_ENUMERATION(base::FieldTrial::MakeName(
-        "Throttling.RequestThrottled", "ThrottlingEnabled"), reject_count, 2);
+        "Throttling.RequestThrottled", "HttpThrottlingEnabled"),
+        reject_count, 2);
   }
 
   return reject_request;
 }
 
 int64 URLRequestThrottlerEntry::ReserveSendingTimeForNextRequest(
     const base::TimeTicks& earliest_time) {
   base::TimeTicks now = ImplGetTimeNow();
 
   // If a lot of requests were successfully made recently,
@@ skipping 145 matching lines @@
   net_log_.AddEvent(
       NetLog::TYPE_THROTTLING_GOT_CUSTOM_RETRY_AFTER,
       make_scoped_refptr(new RetryAfterParameters(url_id_, value_ms)));
 
   base::TimeDelta value = base::TimeDelta::FromMilliseconds(value_ms);
   GetBackoffEntry()->SetCustomReleaseTime(ImplGetTimeNow() + value);
 
   UMA_HISTOGRAM_CUSTOM_TIMES(
       "Throttling.CustomRetryAfterMs", value,
       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromHours(12), 50);
-  if (base::FieldTrialList::TrialExists("ThrottlingEnabled")) {
+  if (base::FieldTrialList::TrialExists("HttpThrottlingEnabled")) {
     UMA_HISTOGRAM_CUSTOM_TIMES(
         base::FieldTrial::MakeName("Throttling.CustomRetryAfterMs",
-                                   "ThrottlingEnabled"), value,
+                                   "HttpThrottlingEnabled"), value,
         base::TimeDelta::FromSeconds(1), base::TimeDelta::FromHours(12), 50);
   }
 }
 
 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) {
   // This is essentially the same as the "Net.HttpResponseCode" UMA stat
   // but we are tracking it separately here for the throttling experiment
   // to make sure we count only the responses seen by throttling.
   // TODO(joi): Remove after experiment.
   UMA_HISTOGRAM_ENUMERATION("Throttling.HttpResponseCode", response_code, 600);
-  if (base::FieldTrialList::TrialExists("ThrottlingEnabled")) {
+  if (base::FieldTrialList::TrialExists("HttpThrottlingEnabled")) {
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("Throttling.HttpResponseCode",
-                                   "ThrottlingEnabled"),
+                                   "HttpThrottlingEnabled"),
         response_code, 600);
   }
 
   // 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);
 
-      if (base::FieldTrialList::TrialExists("ThrottlingEnabled")) {
+      if (base::FieldTrialList::TrialExists("HttpThrottlingEnabled")) {
         UMA_HISTOGRAM_COUNTS(base::FieldTrial::MakeName(
-            "Throttling.FailureCountAtSuccess", "ThrottlingEnabled"),
+            "Throttling.FailureCountAtSuccess", "HttpThrottlingEnabled"),
             failure_count);
         UMA_HISTOGRAM_CUSTOM_TIMES(base::FieldTrial::MakeName(
-            "Throttling.PerceivedDowntime", "ThrottlingEnabled"), down_time,
+            "Throttling.PerceivedDowntime", "HttpThrottlingEnabled"), 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_;
 }
 
 }  // namespace net