Move test_url_fetcher_factory.* from content/ to net/url_request

net/url_request/test_url_fetcher_factory.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/public/test/test_url_fetcher_factory.h"
+#include "net/url_request/test_url_fetcher_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_impl.h"
 #include "net/url_request/url_request_status.h"
 
+namespace net {
+
 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
-    net::URLFetcherFactory* factory) {
-  DCHECK(!net::URLFetcherImpl::factory());
-  net::URLFetcherImpl::set_factory(factory);
+    URLFetcherFactory* factory) {
+  DCHECK(!URLFetcherImpl::factory());
+  URLFetcherImpl::set_factory(factory);
 }
 
 ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
-  DCHECK(net::URLFetcherImpl::factory());
-  net::URLFetcherImpl::set_factory(NULL);
+  DCHECK(URLFetcherImpl::factory());
+  URLFetcherImpl::set_factory(NULL);
 }
 
 TestURLFetcher::TestURLFetcher(int id,
                                const GURL& url,
-                               net::URLFetcherDelegate* d)
+                               URLFetcherDelegate* d)
     : id_(id),
       original_url_(url),
       delegate_(d),
       did_receive_last_chunk_(false),
       fake_load_flags_(0),
       fake_response_code_(-1),
       fake_response_destination_(STRING),
       fake_was_fetched_via_proxy_(false),
       fake_max_retries_(0) {
 }
@@ skipping 31 matching lines @@
     const std::string& extra_request_headers) {
   fake_extra_request_headers_.Clear();
   fake_extra_request_headers_.AddHeadersFromString(extra_request_headers);
 }
 
 void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) {
   fake_extra_request_headers_.AddHeaderFromString(header_line);
 }
 
 void TestURLFetcher::GetExtraRequestHeaders(
-    net::HttpRequestHeaders* headers) const {
+    HttpRequestHeaders* headers) const {
   *headers = fake_extra_request_headers_;
 }
 
 void TestURLFetcher::SetRequestContext(
-    net::URLRequestContextGetter* request_context_getter) {
+    URLRequestContextGetter* request_context_getter) {
 }
 
 void TestURLFetcher::SetFirstPartyForCookies(
     const GURL& first_party_for_cookies) {
 }
 
 void TestURLFetcher::SetURLRequestUserData(
     const void* key,
     const CreateDataCallback& create_data_callback) {
 }
@@ skipping 18 matching lines @@
 
 void TestURLFetcher::SaveResponseToFileAtPath(
     const FilePath& file_path,
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
 }
 
 void TestURLFetcher::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
 }
 
-net::HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
+HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
   return fake_response_headers_;
 }
 
-net::HostPortPair TestURLFetcher::GetSocketAddress() const {
+HostPortPair TestURLFetcher::GetSocketAddress() const {
   NOTIMPLEMENTED();
-  return net::HostPortPair();
+  return HostPortPair();
 }
 
 bool TestURLFetcher::WasFetchedViaProxy() const {
   return fake_was_fetched_via_proxy_;
 }
 
 void TestURLFetcher::Start() {
   // Overriden to do nothing. It is assumed the caller will notify the delegate.
 }
 
 const GURL& TestURLFetcher::GetOriginalURL() const {
   return original_url_;
 }
 
 const GURL& TestURLFetcher::GetURL() const {
   return fake_url_;
 }
 
-const net::URLRequestStatus& TestURLFetcher::GetStatus() const {
+const URLRequestStatus& TestURLFetcher::GetStatus() const {
   return fake_status_;
 }
 
 int TestURLFetcher::GetResponseCode() const {
   return fake_response_code_;
 }
 
-const net::ResponseCookies& TestURLFetcher::GetCookies() const {
+const ResponseCookies& TestURLFetcher::GetCookies() const {
   return fake_cookies_;
 }
 
 bool TestURLFetcher::FileErrorOccurred(
     base::PlatformFileError* out_error_code) const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void TestURLFetcher::ReceivedContentWasMalformed() {
@@ skipping 10 matching lines @@
 
 bool TestURLFetcher::GetResponseAsFilePath(
     bool take_ownership, FilePath* out_response_path) const {
   if (fake_response_destination_ != TEMP_FILE)
     return false;
 
   *out_response_path = fake_response_file_path_;
   return true;
 }
 
-void TestURLFetcher::set_status(const net::URLRequestStatus& status) {
+void TestURLFetcher::set_status(const URLRequestStatus& status) {
   fake_status_ = status;
 }
 
 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
   fake_was_fetched_via_proxy_ = flag;
 }
 
 void TestURLFetcher::set_response_headers(
-    scoped_refptr<net::HttpResponseHeaders> headers) {
+    scoped_refptr<HttpResponseHeaders> headers) {
   fake_response_headers_ = headers;
 }
 
 void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
   fake_backoff_delay_ = backoff_delay;
 }
 
 void TestURLFetcher::SetResponseString(const std::string& response) {
   fake_response_destination_ = STRING;
   fake_response_string_ = response;
 }
 
 void TestURLFetcher::SetResponseFilePath(const FilePath& path) {
   fake_response_destination_ = TEMP_FILE;
   fake_response_file_path_ = path;
 }
 
 TestURLFetcherFactory::TestURLFetcherFactory()
     : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 TestURLFetcherFactory::~TestURLFetcherFactory() {}
 
-net::URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
+URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
-    net::URLFetcher::RequestType request_type,
-    net::URLFetcherDelegate* d) {
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
   TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
   fetchers_[id] = fetcher;
   return fetcher;
 }
 
 TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
   Fetchers::const_iterator i = fetchers_.find(id);
   return i == fetchers_.end() ? NULL : i->second;
 }
 
 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
   Fetchers::iterator i = fetchers_.find(id);
   DCHECK(i != fetchers_.end());
   fetchers_.erase(i);
 }
 
 // This class is used by the FakeURLFetcherFactory below.
 class FakeURLFetcher : public TestURLFetcher {
  public:
   // Normal URL fetcher constructor but also takes in a pre-baked response.
   FakeURLFetcher(const GURL& url,
-                 net::URLFetcherDelegate* d,
+                 URLFetcherDelegate* d,
                  const std::string& response_data, bool success)
     : TestURLFetcher(0, url, d),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
-    set_status(net::URLRequestStatus(
-        success ? net::URLRequestStatus::SUCCESS :
-            net::URLRequestStatus::FAILED,
+    set_status(URLRequestStatus(
+        success ? URLRequestStatus::SUCCESS :
+            URLRequestStatus::FAILED,
         0));
     set_response_code(success ? 200 : 500);
     SetResponseString(response_data);
   }
 
   // Start the request.  This will call the given delegate asynchronously
   // with the pre-baked response as parameter.
   virtual void Start() OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FakeURLFetcher);
 };
 
 FakeURLFetcherFactory::FakeURLFetcherFactory()
     : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       default_factory_(NULL) {
 }
 
 FakeURLFetcherFactory::FakeURLFetcherFactory(
-    net::URLFetcherFactory* default_factory)
+    URLFetcherFactory* default_factory)
     : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       default_factory_(default_factory) {
 }
 
 FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
 
-net::URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
+URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
-    net::URLFetcher::RequestType request_type,
-    net::URLFetcherDelegate* d) {
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
   FakeResponseMap::const_iterator it = fake_responses_.find(url);
   if (it == fake_responses_.end()) {
     if (default_factory_ == NULL) {
       // If we don't have a baked response for that URL we return NULL.
       DLOG(ERROR) << "No baked response for URL: " << url.spec();
       return NULL;
     } else {
       return default_factory_->CreateURLFetcher(id, url, request_type, d);
     }
   }
   return new FakeURLFetcher(url, d, it->second.first, it->second.second);
 }
 
 void FakeURLFetcherFactory::SetFakeResponse(const std::string& url,
                                             const std::string& response_data,
                                             bool success) {
   // Overwrite existing URL if it already exists.
   fake_responses_[GURL(url)] = std::make_pair(response_data, success);
 }
 
 void FakeURLFetcherFactory::ClearFakeResponses() {
   fake_responses_.clear();
 }
 
 URLFetcherImplFactory::URLFetcherImplFactory() {}
 
 URLFetcherImplFactory::~URLFetcherImplFactory() {}
 
-net::URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
+URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
     int id,
     const GURL& url,
-    net::URLFetcher::RequestType request_type,
-    net::URLFetcherDelegate* d) {
-  return new net::URLFetcherImpl(url, request_type, d);
+    URLFetcher::RequestType request_type,
+    URLFetcherDelegate* d) {
+  return new URLFetcherImpl(url, request_type, d);
 }
+
+}  // namespace net