Change most content::URLFetcher references to net::URLFetcher

content/common/net/url_fetcher_impl_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 "content/common/net/url_fetcher_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 108 matching lines @@
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   MessageLoopForIO io_loop_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   URLFetcherImpl* fetcher_;
   const scoped_ptr<TestURLRequestContext> context_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherTest::OnURLFetchComplete(const net::URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
 
   std::string data;
@@ skipping 217 matching lines @@
   // the URLFetcher should own the temp file, so that we can test
   // disowning prevents the file from being deleted.
   bool take_ownership_of_file_;
 
   // Expected file error code for the test.
   // PLATFORM_FILE_OK when expecting success.
   base::PlatformFileError expected_file_error_;
 };
 
 void URLFetcherPostTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::POST, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   fetcher_->SetUploadData("application/x-www-form-urlencoded",
                           "bobsyeruncle");
   fetcher_->Start();
 }
 
 void URLFetcherPostTest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 void URLFetcherDownloadProgressTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   previous_progress_ = 0;
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressTest::OnURLFetchDownloadProgress(
     const net::URLFetcher* source, int64 current, int64 total) {
   // Increasing between 0 and total.
   EXPECT_LE(0, current);
   EXPECT_GE(total, current);
   EXPECT_LE(previous_progress_, current);
   previous_progress_ = current;
   EXPECT_EQ(expected_total_, total);
 }
 
 void URLFetcherDownloadProgressCancelTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   cancelled_ = false;
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchDownloadProgress(
     const net::URLFetcher* source, int64 current, int64 total) {
   EXPECT_FALSE(cancelled_);
   if (!cancelled_) {
     delete fetcher_;
     cancelled_ = true;
     io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchComplete(
     const net::URLFetcher* source) {
   // Should have been cancelled.
   ADD_FAILURE();
   delete fetcher_;
   io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void URLFetcherUploadProgressTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::POST, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   previous_progress_ = 0;
   // Large enough data to require more than one read from UploadDataStream.
   chunk_.assign(1<<16, 'a');
   // Use chunked upload to wait for a timer event of progress notification.
   fetcher_->SetChunkedUpload("application/x-www-form-urlencoded");
   fetcher_->Start();
   number_of_chunks_added_ = 1;
   fetcher_->AppendChunkToUpload(chunk_, false);
@@ skipping 25 matching lines @@
 }
 
 void URLFetcherSocketAddressTest::OnURLFetchComplete(
     const net::URLFetcher* source) {
   EXPECT_EQ("127.0.0.1", source->GetSocketAddress().host());
   EXPECT_EQ(expected_port_, source->GetSocketAddress().port());
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   start_time_ = Time::Now();
   fetcher_->SetMaxRetries(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTest::OnURLFetchComplete(
     const net::URLFetcher* source) {
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
@@ skipping 19 matching lines @@
     } 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);
       URLFetcherTest::OnURLFetchComplete(source);
     }
   }
 }
 
 void URLFetcherProtectTestPassedThrough::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   fetcher_->SetAutomaticallyRetryOn5xx(false);
   start_time_ = Time::Now();
   fetcher_->SetMaxRetries(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTestPassedThrough::OnURLFetchComplete(
     const net::URLFetcher* source) {
@@ skipping 42 matching lines @@
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 
   // The rest is the same as URLFetcherTest::OnURLFetchComplete.
   delete fetcher_;
   io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   CancelTestURLRequestContextGetter* context_getter =
       new CancelTestURLRequestContextGetter(io_message_loop_proxy(),
                                             url);
   fetcher_->SetRequestContext(context_getter);
   fetcher_->SetMaxRetries(2);
   fetcher_->Start();
   // We need to wait for the creation of the net::URLRequestContext, since we
   // rely on it being destroyed as a signal to end the test.
   context_getter->WaitForContextCreation();
   CancelRequest();
@@ skipping 33 matching lines @@
                       // same thread that CreateFetcher() did.
 
     io_message_loop_proxy()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     // 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.
   }
 }
 
 void URLFetcherFileTest::CreateFetcherForFile(const GURL& url,
                                               const FilePath& file_path) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
 
   // Use the IO message loop to do the file operations in this test.
   fetcher_->SaveResponseToFileAtPath(file_path, io_message_loop_proxy());
   fetcher_->Start();
 }
 
 void URLFetcherFileTest::CreateFetcherForTempFile(const GURL& url) {
-  fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
+  fetcher_ = new URLFetcherImpl(url, net::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
 
   // Use the IO message loop to do the file operations in this test.
   fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
   fetcher_->Start();
 }
 
 void URLFetcherFileTest::OnURLFetchComplete(const net::URLFetcher* source) {
   if (expected_file_error_ == base::PLATFORM_FILE_OK) {
@@ skipping 495 matching lines @@
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunAllPending();
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 }  // namespace.