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

net/url_request/url_request_throttler_simulation_unittest.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.
 
 // The tests in this file attempt to verify the following through simulation:
 // a) That a server experiencing overload will actually benefit from the
 //    anti-DDoS throttling logic, i.e. that its traffic spike will subside
 //    and be distributed over a longer period of time;
 // b) That "well-behaved" clients of a server under DDoS attack actually
 //    benefit from the anti-DDoS throttling logic; and
 // c) That the approximate increase in "perceived downtime" introduced by
 //    anti-DDoS throttling for various different actual downtimes is what
 //    we expect it to be.
 
 #include <cmath>
 #include <limits>
 #include <vector>
 
 #include "base/environment.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
 #include "base/time.h"
+#include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "net/url_request/url_request_throttler_test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 namespace {
 
@@ skipping 82 matching lines @@
 // after all |Requester| objects.
 class Server : public DiscreteTimeSimulation::Actor {
  public:
   Server(int max_queries_per_tick,
          double request_drop_ratio)
       : max_queries_per_tick_(max_queries_per_tick),
         request_drop_ratio_(request_drop_ratio),
         num_overloaded_ticks_remaining_(0),
         num_current_tick_queries_(0),
         num_overloaded_ticks_(0),
-        max_experienced_queries_per_tick_(0) {
+        max_experienced_queries_per_tick_(0),
+        mock_request_(GURL(), NULL) {
   }
 
   void SetDowntime(const TimeTicks& start_time, const TimeDelta& duration) {
     start_downtime_ = start_time;
     end_downtime_ = start_time + duration;
   }
 
   virtual void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
     now_ = absolute_time;
   }
@@ skipping 16 matching lines @@
     requests_per_tick_.push_back(num_current_tick_queries_);
     num_current_tick_queries_ = 0;
   }
 
   // This is called by Requester. It returns the response code from
   // the server.
   int HandleRequest() {
     ++num_current_tick_queries_;
     if (!start_downtime_.is_null() &&
         start_downtime_ < now_ && now_ < end_downtime_) {
-      // TODO(joi): For the simulation measuring the increase in perceived
+      // For the simulation measuring the increase in perceived
       // downtime, it might be interesting to count separately the
       // queries seen by the server (assuming a front-end reverse proxy
       // is what actually serves up the 503s in this case) so that we could
       // visualize the traffic spike seen by the server when it comes up,
       // which would in many situations be ameliorated by the anti-DDoS
       // throttling.
       return 503;
     }
 
     if ((num_overloaded_ticks_remaining_ > 0 ||
          num_current_tick_queries_ > max_queries_per_tick_) &&
         base::RandDouble() < request_drop_ratio_) {
       return 503;
     }
 
     return 200;
   }
 
   int num_overloaded_ticks() const {
     return num_overloaded_ticks_;
   }
 
   int max_experienced_queries_per_tick() const {
     return max_experienced_queries_per_tick_;
   }
 
+  const URLRequest& mock_request() const {
+    return mock_request_;
+  }
+
   std::string VisualizeASCII(int terminal_width) {
     // Account for | characters we place at left of graph.
     terminal_width -= 1;
 
     VerboseOut("Overloaded for %d of %d ticks.\n",
                num_overloaded_ticks_, requests_per_tick_.size());
     VerboseOut("Got maximum of %d requests in a tick.\n\n",
                max_experienced_queries_per_tick_);
 
     VerboseOut("Traffic graph:\n\n");
@@ skipping 75 matching lines @@
   TimeTicks now_;
   TimeTicks start_downtime_;  // Can be 0 to say "no downtime".
   TimeTicks end_downtime_;
   const int max_queries_per_tick_;
   const double request_drop_ratio_;  // Ratio of requests to 503 when failing.
   int num_overloaded_ticks_remaining_;
   int num_current_tick_queries_;
   int num_overloaded_ticks_;
   int max_experienced_queries_per_tick_;
   std::vector<int> requests_per_tick_;
+  TestURLRequest mock_request_;
 
   DISALLOW_COPY_AND_ASSIGN(Server);
 };
 
-class TestingURLRequestThrottlerManager : public URLRequestThrottlerManager {
- public:
-  TestingURLRequestThrottlerManager() : URLRequestThrottlerManager() {
-  }
-};
-
 // Mock throttler entry used by Requester class.
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(
       URLRequestThrottlerManager* manager)
       : URLRequestThrottlerEntry(manager, ""),
         mock_backoff_entry_(&backoff_policy_) {
   }
 
   virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
@@ skipping 116 matching lines @@
     TimeDelta current_jitter = TimeDelta::FromMilliseconds(
         request_jitter_.InMilliseconds() * base::RandDouble());
     if (base::RandInt(0, 1)) {
       effective_delay -= current_jitter;
     } else {
       effective_delay += current_jitter;
     }
 
     if (throttler_entry_->fake_now() - time_of_last_attempt_ >
         effective_delay) {
-      if (!throttler_entry_->ShouldRejectRequest(0)) {
+      if (!throttler_entry_->ShouldRejectRequest(server_->mock_request())) {
         int status_code = server_->HandleRequest();
         MockURLRequestThrottlerHeaderAdapter response_headers(status_code);
         throttler_entry_->UpdateWithResponse("", &response_headers);
 
         if (status_code == 200) {
           if (results_)
             results_->AddSuccess();
 
           if (last_attempt_was_failure_) {
             last_downtime_duration_ =
@@ skipping 45 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Requester);
 };
 
 void SimulateAttack(Server* server,
                     RequesterResults* attacker_results,
                     RequesterResults* client_results,
                     bool enable_throttling) {
   const size_t kNumAttackers = 50;
   const size_t kNumClients = 50;
   DiscreteTimeSimulation simulation;
-  TestingURLRequestThrottlerManager manager;
+  URLRequestThrottlerManager manager;
   ScopedVector<Requester> requesters;
   for (size_t i = 0; i < kNumAttackers; ++i) {
     // Use a tiny time_between_requests so the attackers will ping the
     // server at every tick of the simulation.
     scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
         new MockURLRequestThrottlerEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
       Requester* attacker = new Requester(throttler_entry.get(),
@@ skipping 82 matching lines @@
 double SimulateDowntime(const TimeDelta& duration,
                         const TimeDelta& average_client_interval,
                         bool enable_throttling) {
   TimeDelta time_between_ticks = duration / 200;
   TimeTicks start_downtime = TimeTicks() + (duration / 2);
 
   // A server that never rejects requests, but will go down for maintenance.
   Server server(std::numeric_limits<int>::max(), 1.0);
   server.SetDowntime(start_downtime, duration);
 
-  TestingURLRequestThrottlerManager manager;
+  URLRequestThrottlerManager manager;
   scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
       new MockURLRequestThrottlerEntry(&manager));
   if (!enable_throttling)
     throttler_entry->DisableBackoffThrottling();
 
   Requester requester(
       throttler_entry.get(), average_client_interval, &server, NULL);
   requester.SetStartupJitter(duration / 3);
   requester.SetRequestJitter(average_client_interval);
 
@@ skipping 135 matching lines @@
     trials[i].PrintTrialDescription();
     trials[i].stats.ReportTrialResult(increase_ratio);
   }
 
   VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
   VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
 }
 
 }  // namespace
 }  // namespace net