Remove minidump analysis aides from URLRequestThrottlerManager. New

net/url_request/url_request_throttler_unittest.cc

 // Copyright (c) 2010 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 "base/pickle.h"
 #include "base/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "net/base/test_completion_callback.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 class MockURLRequestThrottlerManager;
 
+class MockBackoffEntry : public net::BackoffEntry {
+public:
+  MockBackoffEntry(const net::BackoffEntry::Policy* policy)
+      : net::BackoffEntry(policy), fake_now_(TimeTicks()) {
+  }
+
+  TimeTicks GetTimeNow() const {
+    return fake_now_;
+  }
+
+  void SetFakeNow(TimeTicks now) {
+    fake_now_ = now;
+  }
+
+private:
+  TimeTicks fake_now_;
+};
+
 class MockURLRequestThrottlerEntry : public net::URLRequestThrottlerEntry {
  public :
-  MockURLRequestThrottlerEntry() {}
+   MockURLRequestThrottlerEntry() : mock_backoff_entry_(&backoff_policy_) {}
   MockURLRequestThrottlerEntry(
       const TimeTicks& exponential_backoff_release_time,
       const TimeTicks& sliding_window_release_time,
       const TimeTicks& fake_now)
-      : fake_time_now_(fake_now) {
+      : fake_time_now_(fake_now),
+        mock_backoff_entry_(&backoff_policy_) {
+    mock_backoff_entry_.SetFakeNow(fake_now);
     set_exponential_backoff_release_time(exponential_backoff_release_time);
     set_sliding_window_release_time(sliding_window_release_time);
   }
   virtual ~MockURLRequestThrottlerEntry() {}
 
+  const net::BackoffEntry* GetBackoffEntry() const {
+    return &mock_backoff_entry_;
+  }
+
+  net::BackoffEntry* GetBackoffEntry() {
+    return &mock_backoff_entry_;
+  }
+
   void ResetToBlank(const TimeTicks& time_now) {
     fake_time_now_ = time_now;
-    set_exponential_backoff_release_time(time_now);
-    set_failure_count(0);
+    mock_backoff_entry_.SetFakeNow(time_now);
+
+    GetBackoffEntry()->SetCustomReleaseTime(time_now);
+    GetBackoffEntry()->InformOfRequest(true);  // Sets failure count to 0.
     set_sliding_window_release_time(time_now);
   }
 
   // Overridden for tests.
   virtual TimeTicks GetTimeNow() const { return fake_time_now_; }
 
   void set_exponential_backoff_release_time(
       const base::TimeTicks& release_time) {
-    net::URLRequestThrottlerEntry::set_exponential_backoff_release_time(
-        release_time);
+    GetBackoffEntry()->SetCustomReleaseTime(release_time);
   }
 
   base::TimeTicks sliding_window_release_time() const {
     return net::URLRequestThrottlerEntry::sliding_window_release_time();
   }
 
   void set_sliding_window_release_time(
       const base::TimeTicks& release_time) {
     net::URLRequestThrottlerEntry::set_sliding_window_release_time(
         release_time);
   }
 
   TimeTicks fake_time_now_;
+  MockBackoffEntry mock_backoff_entry_;
 };
 
 class MockURLRequestThrottlerHeaderAdapter
     : public net::URLRequestThrottlerHeaderInterface {
  public:
   MockURLRequestThrottlerHeaderAdapter()
       : fake_retry_value_("0.0"),
         fake_response_code_(0) {
   }
 
@@ skipping 147 matching lines @@
 
 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__),
       TimeAndBool(now_ + kFiveMs, false, __LINE__),
-      TimeAndBool(now_ - lifetime, false, __LINE__),
+      TimeAndBool(now_ - (lifetime - kFiveMs), false, __LINE__),
+      TimeAndBool(now_ - lifetime, true, __LINE__),
       TimeAndBool(now_ - (lifetime + kFiveMs), true, __LINE__)};
 
   for (unsigned int i = 0; i < arraysize(test_values); ++i) {
     entry_->set_exponential_backoff_release_time(test_values[i].time);
     EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result) <<
         "Test case #" << i << " line " << test_values[i].line << " failed";
   }
 }
 
 TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) {
@@ skipping 47 matching lines @@
   for (int i = 0; i < (max_send + 1) / 2; ++i)
     EXPECT_EQ(0, entry_->ReserveSendingTimeForNextRequest(TimeTicks()));
 
   EXPECT_EQ(time_4, entry_->sliding_window_release_time());
 }
 
 TEST(URLRequestThrottlerManager, IsUrlStandardised) {
   MockURLRequestThrottlerManager manager;
   GurlAndString test_values[] = {
       GurlAndString(GURL("http://www.example.com"),
-                    std::string("GOOGYhttp://www.example.com/MONSTA"),
+                    std::string("http://www.example.com/"),
                     __LINE__),
       GurlAndString(GURL("http://www.Example.com"),
-                    std::string("GOOGYhttp://www.example.com/MONSTA"),
+                    std::string("http://www.example.com/"),
                     __LINE__),
       GurlAndString(GURL("http://www.ex4mple.com/Pr4c71c41"),
-                    std::string("GOOGYhttp://www.ex4mple.com/pr4c71c41MONSTA"),
+                    std::string("http://www.ex4mple.com/pr4c71c41"),
                     __LINE__),
-      GurlAndString(
-          GURL("http://www.example.com/0/token/false"),
-          std::string("GOOGYhttp://www.example.com/0/token/falseMONSTA"),
-          __LINE__),
+      GurlAndString(GURL("http://www.example.com/0/token/false"),
+                    std::string("http://www.example.com/0/token/false"),
+                    __LINE__),
       GurlAndString(GURL("http://www.example.com/index.php?code=javascript"),
-                    std::string("GOOGYhttp://www.example.com/index.phpMONSTA"),
+                    std::string("http://www.example.com/index.php"),
                     __LINE__),
       GurlAndString(GURL("http://www.example.com/index.php?code=1#superEntry"),
-                    std::string("GOOGYhttp://www.example.com/index.phpMONSTA"),
+                    std::string("http://www.example.com/index.php"),
                     __LINE__),
       GurlAndString(GURL("http://www.example.com:1234/"),
-                    std::string("GOOGYhttp://www.example.com:1234/MONSTA"),
+                    std::string("http://www.example.com:1234/"),
                     __LINE__)};
 
   for (unsigned int i = 0; i < arraysize(test_values); ++i) {
     std::string temp = manager.DoGetUrlIdFromUrl(test_values[i].url);
     EXPECT_EQ(temp, test_values[i].result) <<
         "Test case #" << i << " line " << test_values[i].line << " failed";
   }
 }
 
 TEST(URLRequestThrottlerManager, AreEntriesBeingCollected) {
@@ skipping 17 matching lines @@
   MockURLRequestThrottlerManager manager;
 
   manager.RegisterRequestUrl(GURL("http://www.example.com/"));
   manager.RegisterRequestUrl(GURL("http://www.google.com/"));
   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());
 }
-
-class DummyResponseHeaders : public net::URLRequestThrottlerHeaderInterface {
- public:
-  DummyResponseHeaders(int response_code) : response_code_(response_code) {}
-
-  std::string GetNormalizedValue(const std::string& key) const {
-    return "";
-  }
-
-  // Returns the HTTP response code associated with the request.
-  int GetResponseCode() const {
-    return response_code_;
-  }
-
- private:
-  int response_code_;
-};
-
-TEST(URLRequestThrottlerManager, StressTest) {
-  MockURLRequestThrottlerManager manager;
-
-  for (int i = 0; i < 10000; ++i) {
-    // Make some entries duplicates or triplicates.
-    int entry_number = i + 2;
-    if (i % 17 == 0) {
-      entry_number = i - 1;
-    } else if ((i - 1) % 17 == 0) {
-      entry_number = i - 2;
-    } else if (i % 13 == 0) {
-      entry_number = i - 1;
-    }
-
-    scoped_refptr<net::URLRequestThrottlerEntryInterface> entry =
-        manager.RegisterRequestUrl(GURL(StringPrintf(
-            "http://bingourl.com/%d", entry_number)));
-    entry->IsDuringExponentialBackoff();
-    entry->GetExponentialBackoffReleaseTime();
-
-    DummyResponseHeaders headers(i % 7 == 0 ? 500 : 200);
-    entry->UpdateWithResponse(&headers);
-    entry->SetEntryLifetimeMsForTest(1);
-
-    entry->IsDuringExponentialBackoff();
-    entry->GetExponentialBackoffReleaseTime();
-    entry->ReserveSendingTimeForNextRequest(base::TimeTicks::Now());
-
-    if (i % 11 == 0) {
-      manager.DoGarbageCollectEntries();
-    }
-  }
-}
-
-// TODO(joi): Remove the debug-only condition after M11 branch point.
-#if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
-TEST(URLRequestThrottlerManager, NullHandlingTest) {
-  MockURLRequestThrottlerManager manager;
-  manager.OverrideEntryForTests(GURL("http://www.foo.com/"), NULL);
-  ASSERT_DEATH({
-      manager.DoGarbageCollectEntries();
-  }, "");
-}
-#endif  // defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)