Remove all "net::" prefixes under net/url_request for code that's

net/url_request/url_request_throttler_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "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 net {
+
 namespace {
 class MockURLRequestThrottlerManager;
 
-class MockBackoffEntry : public net::BackoffEntry {
+class MockBackoffEntry : public BackoffEntry {
  public:
-  explicit MockBackoffEntry(const net::BackoffEntry::Policy* const policy)
-      : net::BackoffEntry(policy), fake_now_(TimeTicks()) {
+  explicit MockBackoffEntry(const BackoffEntry::Policy* const policy)
+      : BackoffEntry(policy), fake_now_(TimeTicks()) {
   }
 
   virtual ~MockBackoffEntry() {}
 
   TimeTicks GetTimeNow() const {
     return fake_now_;
   }
 
   void SetFakeNow(TimeTicks now) {
     fake_now_ = now;
   }
 
  private:
   TimeTicks fake_now_;
 };
 
-class MockURLRequestThrottlerEntry : public net::URLRequestThrottlerEntry {
+class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public :
   MockURLRequestThrottlerEntry() : mock_backoff_entry_(&backoff_policy_) {
     // Some tests become flaky if we have jitter.
     backoff_policy_.jitter_factor = 0.0;
   }
   MockURLRequestThrottlerEntry(
       const TimeTicks& exponential_backoff_release_time,
       const TimeTicks& sliding_window_release_time,
       const TimeTicks& fake_now)
       : fake_time_now_(fake_now),
         mock_backoff_entry_(&backoff_policy_) {
     // Some tests become flaky if we have jitter.
     backoff_policy_.jitter_factor = 0.0;
 
     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 {
+  const BackoffEntry* GetBackoffEntry() const {
     return &mock_backoff_entry_;
   }
 
-  net::BackoffEntry* GetBackoffEntry() {
+  BackoffEntry* GetBackoffEntry() {
     return &mock_backoff_entry_;
   }
 
   void ResetToBlank(const TimeTicks& time_now) {
     fake_time_now_ = time_now;
     mock_backoff_entry_.SetFakeNow(time_now);
 
     GetBackoffEntry()->InformOfRequest(true);  // Sets failure count to 0.
     GetBackoffEntry()->SetCustomReleaseTime(time_now);
     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) {
     GetBackoffEntry()->SetCustomReleaseTime(release_time);
   }
 
   base::TimeTicks sliding_window_release_time() const {
-    return net::URLRequestThrottlerEntry::sliding_window_release_time();
+    return URLRequestThrottlerEntry::sliding_window_release_time();
   }
 
   void set_sliding_window_release_time(
       const base::TimeTicks& release_time) {
-    net::URLRequestThrottlerEntry::set_sliding_window_release_time(
+    URLRequestThrottlerEntry::set_sliding_window_release_time(
         release_time);
   }
 
   TimeTicks fake_time_now_;
   MockBackoffEntry mock_backoff_entry_;
 };
 
 class MockURLRequestThrottlerHeaderAdapter
-    : public net::URLRequestThrottlerHeaderInterface {
+    : public URLRequestThrottlerHeaderInterface {
  public:
   MockURLRequestThrottlerHeaderAdapter()
       : fake_retry_value_("0.0"),
         fake_response_code_(0) {
   }
 
   MockURLRequestThrottlerHeaderAdapter(const std::string& retry_value,
                                        int response_code)
       : fake_retry_value_(retry_value),
         fake_response_code_(response_code) {
   }
 
   virtual ~MockURLRequestThrottlerHeaderAdapter() {}
 
   virtual std::string GetNormalizedValue(const std::string& key) const {
     if (key == MockURLRequestThrottlerEntry::kRetryHeaderName)
       return fake_retry_value_;
     return "";
   }
 
   virtual int GetResponseCode() const { return fake_response_code_; }
 
   std::string fake_retry_value_;
   int fake_response_code_;
 };
 
-class MockURLRequestThrottlerManager : public net::URLRequestThrottlerManager {
+class MockURLRequestThrottlerManager : public URLRequestThrottlerManager {
  public:
   MockURLRequestThrottlerManager() : 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(); }
 
@@ skipping 152 matching lines @@
 
   TimeTicks release_after_failures = entry_->GetExponentialBackoffReleaseTime();
 
   // Inform the entry that a response body was malformed, which is supposed to
   // increase the back-off time.
   entry_->ReceivedContentWasMalformed();
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, SlidingWindow) {
-  int max_send = net::URLRequestThrottlerEntry::kDefaultMaxSendThreshold;
+  int max_send = URLRequestThrottlerEntry::kDefaultMaxSendThreshold;
   int sliding_window =
-      net::URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
+      URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
 
   TimeTicks time_1 = entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(sliding_window / 3);
   TimeTicks time_2 = entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(2 * sliding_window / 3);
   TimeTicks time_3 = entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(sliding_window);
   TimeTicks time_4 = entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(sliding_window + 2 * sliding_window / 3);
 
@@ skipping 66 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());
 }
+
+}  // namespace net