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

net/url_request/url_request_throttler_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.
 
 #include "net/url_request/url_request_throttler_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/test_completion_callback.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_header_interface.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 74 matching lines @@
 
   TimeTicks fake_time_now_;
   MockBackoffEntry mock_backoff_entry_;
 
  protected:
   virtual ~MockURLRequestThrottlerEntry() {}
 };
 
 class MockURLRequestThrottlerManager : public URLRequestThrottlerManager {
  public:
-  MockURLRequestThrottlerManager() : create_entry_index_(0) {}
+  MockURLRequestThrottlerManager()
+      : URLRequestThrottlerManager(&delegate_),
+        create_entry_index_(0) {
+  }
 
   // Method to process the URL using URLRequestThrottlerManager protected
   // method.
   std::string DoGetUrlIdFromUrl(const GURL& url) { return GetIdFromUrl(url); }
 
   // Method to use the garbage collecting method of URLRequestThrottlerManager.
   void DoGarbageCollectEntries() { GarbageCollectEntries(); }
 
   // Returns the number of entries in the map.
   int GetNumberOfEntries() const { return GetNumberOfEntriesForTests(); }
 
   void CreateEntry(bool is_outdated) {
     TimeTicks time = TimeTicks::Now();
     if (is_outdated) {
       time -= TimeDelta::FromMilliseconds(
           MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs + 1000);
     }
     std::string fake_url_string("http://www.fakeurl.com/");
     fake_url_string.append(base::IntToString(create_entry_index_++));
     GURL fake_url(fake_url_string);
     OverrideEntryForTests(
         fake_url,
         new MockURLRequestThrottlerEntry(this, time, TimeTicks::Now(),
                                          TimeTicks::Now()));
   }
 
  private:
   int create_entry_index_;
+  TestURLRequestThrottlerManagerDelegate delegate_;
 };
 
 struct TimeAndBool {
   TimeAndBool(const TimeTicks& time_value, bool expected, int line_num) {
     time = time_value;
     result = expected;
     line = line_num;
   }
   TimeTicks time;
   bool result;
@@ skipping 78 matching lines @@
   original_samples_.clear();
 }
 
 std::ostream& operator<<(std::ostream& out, const base::TimeTicks& time) {
   return out << time.ToInternalValue();
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceDuringExponentialBackoff) {
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
-  EXPECT_TRUE(entry_->ShouldRejectRequest(0));
+  EXPECT_TRUE(entry_->ShouldRejectRequest(NULL, 0));
 
   // Also end-to-end test the load flags exceptions.
-  EXPECT_FALSE(entry_->ShouldRejectRequest(LOAD_MAYBE_USER_GESTURE));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(NULL, LOAD_MAYBE_USER_GESTURE));
 
   CalculateHistogramDeltas();
   ASSERT_EQ(1, samples_["Throttling.RequestThrottled"].counts(0));
   ASSERT_EQ(1, samples_["Throttling.RequestThrottled"].counts(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
   entry_->set_exponential_backoff_release_time(entry_->fake_time_now_);
-  EXPECT_FALSE(entry_->ShouldRejectRequest(0));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(NULL, 0));
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
-  EXPECT_FALSE(entry_->ShouldRejectRequest(0));
+  EXPECT_FALSE(entry_->ShouldRejectRequest(NULL, 0));
 
   CalculateHistogramDeltas();
   ASSERT_EQ(2, samples_["Throttling.RequestThrottled"].counts(0));
   ASSERT_EQ(0, samples_["Throttling.RequestThrottled"].counts(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
   entry_->UpdateWithResponse("", &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "A failure should increase the release_time";
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) {
   MockURLRequestThrottlerHeaderAdapter success_response(200);
   entry_->UpdateWithResponse("", &success_response);
   EXPECT_EQ(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "A success should not add any delay";
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccessThenFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
   MockURLRequestThrottlerHeaderAdapter success_response(200);
   entry_->UpdateWithResponse("", &success_response);
   entry_->UpdateWithResponse("", &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "This scenario should add delay";
   entry_->UpdateWithResponse("", &success_response);
-
-  CalculateHistogramDeltas();
-  ASSERT_EQ(1, samples_["Throttling.FailureCountAtSuccess"].counts(1));
-  ASSERT_EQ(1, samples_["Throttling.PerceivedDowntime"].TotalCount());
 }
 
 TEST_F(URLRequestThrottlerEntryTest, IsEntryReallyOutdated) {
   TimeDelta lifetime = TimeDelta::FromMilliseconds(
       MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs);
   const TimeDelta kFiveMs = TimeDelta::FromMilliseconds(5);
 
   TimeAndBool test_values[] = {
       TimeAndBool(now_, false, __LINE__),
       TimeAndBool(now_ - kFiveMs, false, __LINE__),
@@ skipping 136 matching lines @@
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0?code=1"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/index/0#lolsaure"));
 
   EXPECT_EQ(3, manager.GetNumberOfEntries());
 }
 
 void ExpectEntryAllowsAllOnErrorIfOptedOut(
     net::URLRequestThrottlerEntryInterface* entry,
     bool opted_out) {
-  EXPECT_FALSE(entry->ShouldRejectRequest(0));
+  EXPECT_FALSE(entry->ShouldRejectRequest(NULL, 0));
   MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
   for (int i = 0; i < 10; ++i) {
     // Host doesn't really matter in this scenario so we skip it.
     entry->UpdateWithResponse("", &failure_adapter);
   }
-  EXPECT_NE(opted_out, entry->ShouldRejectRequest(0));
+  EXPECT_NE(opted_out, entry->ShouldRejectRequest(NULL, 0));
 
   if (opted_out) {
     // We're not mocking out GetTimeNow() in this scenario
     // so add a 100 ms buffer to avoid flakiness (that should always
     // give enough time to get from the TimeTicks::Now() call here
     // to the TimeTicks::Now() call in the entry class).
     EXPECT_GT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
               entry->GetExponentialBackoffReleaseTime());
   } else {
     // As above, add 100 ms.
@@ skipping 39 matching lines @@
 TEST(URLRequestThrottlerManager, ClearOnNetworkChange) {
   for (int i = 0; i < 3; ++i) {
     MockURLRequestThrottlerManager manager;
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_before =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
     for (int j = 0; j < 10; ++j) {
       // Host doesn't really matter in this scenario so we skip it.
       entry_before->UpdateWithResponse("", &failure_adapter);
     }
-    EXPECT_TRUE(entry_before->ShouldRejectRequest(0));
+    EXPECT_TRUE(entry_before->ShouldRejectRequest(NULL, 0));
 
     switch (i) {
       case 0:
         manager.OnIPAddressChanged();
         break;
       case 1:
         manager.OnConnectionTypeChanged(
             net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
         break;
       case 2:
         manager.OnConnectionTypeChanged(
             net::NetworkChangeNotifier::CONNECTION_NONE);
         break;
       default:
         FAIL();
     }
 
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
-    EXPECT_FALSE(entry_after->ShouldRejectRequest(0));
+    EXPECT_FALSE(entry_after->ShouldRejectRequest(NULL, 0));
   }
 }
 
 }  // namespace net