Move URLFetcherDelegate to net/ and split URLFetcher between net/ and content/

chrome/service/cloud_print/cloud_print_url_fetcher_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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
@@ skipping 76 matching lines @@
 class CloudPrintURLFetcherTest : public testing::Test,
                                  public CloudPrintURLFetcherDelegate {
  public:
   CloudPrintURLFetcherTest() : max_retries_(0), fetcher_(NULL) { }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url, int max_retries);
 
   // CloudPrintURLFetcher::Delegate
   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       const net::URLRequestStatus& status,
       int response_code,
       const net::ResponseCookies& cookies,
       const std::string& data);
 
   virtual CloudPrintURLFetcher::ResponseAction OnRequestAuthError() {
     ADD_FAILURE();
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
@@ skipping 32 matching lines @@
   Time start_time_;
   scoped_refptr<TestCloudPrintURLFetcher> fetcher_;
 };
 
 class CloudPrintURLFetcherBasicTest : public CloudPrintURLFetcherTest {
  public:
   CloudPrintURLFetcherBasicTest()
       : handle_raw_response_(false), handle_raw_data_(false) { }
   // CloudPrintURLFetcher::Delegate
   virtual CloudPrintURLFetcher::ResponseAction HandleRawResponse(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       const net::URLRequestStatus& status,
       int response_code,
       const net::ResponseCookies& cookies,
       const std::string& data);
 
   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       const std::string& data);
 
   virtual CloudPrintURLFetcher::ResponseAction HandleJSONData(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       DictionaryValue* json_data,
       bool succeeded);
 
   void SetHandleRawResponse(bool handle_raw_response) {
     handle_raw_response_ = handle_raw_response;
   }
   void SetHandleRawData(bool handle_raw_data) {
     handle_raw_data_ = handle_raw_data;
   }
  private:
   bool handle_raw_response_;
   bool handle_raw_data_;
 };
 
 // Version of CloudPrintURLFetcherTest that tests overload protection.
 class CloudPrintURLFetcherOverloadTest : public CloudPrintURLFetcherTest {
  public:
   CloudPrintURLFetcherOverloadTest() : response_count_(0) {
   }
 
   // CloudPrintURLFetcher::Delegate
   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       const std::string& data);
 
  private:
   int response_count_;
 };
 
 // Version of CloudPrintURLFetcherTest that tests backoff protection.
 class CloudPrintURLFetcherRetryBackoffTest : public CloudPrintURLFetcherTest {
  public:
   CloudPrintURLFetcherRetryBackoffTest() : response_count_(0) {
   }
 
   // CloudPrintURLFetcher::Delegate
   virtual CloudPrintURLFetcher::ResponseAction HandleRawData(
-      const content::URLFetcher* source,
+      const net::URLFetcher* source,
       const GURL& url,
       const std::string& data);
 
   virtual void OnRequestGiveUp();
 
  private:
   int response_count_;
 };
 
 
 void CloudPrintURLFetcherTest::CreateFetcher(const GURL& url, int max_retries) {
   fetcher_ = new TestCloudPrintURLFetcher(io_message_loop_proxy());
 
   // Registers an entry for test url. It only allows 3 requests to be sent
   // in 200 milliseconds.
   scoped_refptr<net::URLRequestThrottlerEntry> entry(
       new net::URLRequestThrottlerEntry(
           fetcher_->throttler_manager(), "", 200, 3, 1, 2.0, 0.0, 256));
   fetcher_->throttler_manager()->OverrideEntryForTests(url, entry);
 
   max_retries_ = max_retries;
   start_time_ = Time::Now();
   fetcher_->StartGetRequest(url, this, max_retries_, std::string());
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherTest::HandleRawResponse(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   EXPECT_TRUE(status.is_success());
   EXPECT_EQ(200, response_code);  // HTTP OK
   EXPECT_FALSE(data.empty());
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherBasicTest::HandleRawResponse(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   EXPECT_TRUE(status.is_success());
   EXPECT_EQ(200, response_code);  // HTTP OK
   EXPECT_FALSE(data.empty());
 
   if (handle_raw_response_) {
     // If the current message loop is not the IO loop, it will be shut down when
     // the main loop returns and this thread subsequently goes out of scope.
     io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherBasicTest::HandleRawData(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     const std::string& data) {
   // We should never get here if we returned true in HandleRawResponse
   EXPECT_FALSE(handle_raw_response_);
   if (handle_raw_data_) {
     io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherBasicTest::HandleJSONData(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   // We should never get here if we returned true in one of the above methods.
   EXPECT_FALSE(handle_raw_response_);
   EXPECT_FALSE(handle_raw_data_);
   io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherOverloadTest::HandleRawData(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     const std::string& data) {
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
   response_count_++;
   if (response_count_ < 20) {
     fetcher_->StartGetRequest(url,
                               this,
                               max_retries_,
                               std::string());
   } else {
     // We have already sent 20 requests continuously. And we expect that
     // it takes more than 1 second due to the overload protection settings.
     EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
     io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 CloudPrintURLFetcherRetryBackoffTest::HandleRawData(
-    const content::URLFetcher* source,
+    const net::URLFetcher* source,
     const GURL& url,
     const std::string& data) {
   response_count_++;
   // First attempt + 11 retries = 12 total responses.
   EXPECT_LE(response_count_, 12);
   return CloudPrintURLFetcher::RETRY_REQUEST;
 }
 
 void CloudPrintURLFetcherRetryBackoffTest::OnRequestGiveUp() {
   // It takes more than 200 ms to finish all 11 requests.
@@ skipping 44 matching lines @@
                               FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("defaultresponse"));
   CreateFetcher(url, 11);
 
   MessageLoop::current()->Run();
 }
 
 }  // namespace.