Make test URLFetcher implementations not derive from the URLFetcher implementation, since we want...

content/common/net/url_fetcher.cc

 // 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 "content/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "content/public/common/url_fetcher_delegate.h"
+#include "content/public/common/url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 424 matching lines @@
   if (!temp_file_.empty()) {
     base::FileUtilProxy::Delete(
         file_message_loop_proxy_, temp_file_,
         false,  // No need to recurse, as the path is to a file.
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
     DisownTempFile();
   }
 }
 
 // static
-URLFetcher::Factory* URLFetcher::factory_ = NULL;
+static content::URLFetcherFactory* g_factory = NULL;

[wtc, 2011/10/26 23:34:46]

Remove the "// static" comment on the previous line because
this is no longer a static data member.

[wtc, 2011/10/27 21:29:16]

Just wondering: why did you change this static member to a
global variable?

[jam, 2011/10/27 22:34:41]

because now I need to use it from the static content::URLFetcher method

 
 // static
 static bool g_interception_enabled = false;
 
 // static
 content::URLFetcher* content::URLFetcher::Create(
     const GURL& url,
     RequestType request_type,
     content::URLFetcherDelegate* d) {
   return new ::URLFetcher(url, request_type, d);
 }
 
 // static
 content::URLFetcher* content::URLFetcher::Create(
     int id,
     const GURL& url,
     RequestType request_type,
     content::URLFetcherDelegate* d) {
-  return ::URLFetcher::Create(id, url, request_type, d);
+  return g_factory ? g_factory->CreateURLFetcher(id, url, request_type, d) :
+                     new ::URLFetcher(url, request_type, d);
 }
 
 // static
 void content::URLFetcher::CancelAll() {
   ::URLFetcher::CancelAll();
 }
 
 // static
 void content::URLFetcher::SetEnableInterceptionForTests(bool enabled) {
   g_interception_enabled = enabled;
 }
 
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
                        content::URLFetcherDelegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))) {
 }
 
 URLFetcher::~URLFetcher() {
   core_->Stop();
 }
 
-// static
-URLFetcher* URLFetcher::Create(int id, const GURL& url,
-                               RequestType request_type,
-                               content::URLFetcherDelegate* d) {
-  return factory_ ? factory_->CreateURLFetcher(id, url, request_type, d) :
-                    new URLFetcher(url, request_type, d);
-}
-
 URLFetcher::Core::Core(URLFetcher* fetcher,
                        const GURL& original_url,
                        RequestType request_type,
                        content::URLFetcherDelegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::current()),
@@ skipping 454 matching lines @@
 
 int URLFetcher::GetMaxRetries() const {
   return core_->max_retries_;
 }
 
 
 base::TimeDelta URLFetcher::GetBackoffDelay() const {
   return core_->backoff_delay_;
 }
 
-void URLFetcher::SetBackoffDelayForTesting(
-    base::TimeDelta backoff_delay) {
-  core_->backoff_delay_ = backoff_delay;
-}
-
 void URLFetcher::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
   core_->response_destination_ = TEMP_FILE;
 }
 
 net::HttpResponseHeaders* URLFetcher::GetResponseHeaders() const {
   return core_->response_headers_;
 }
 
@@ skipping 68 matching lines @@
 }
 
 bool URLFetcher::GetResponseAsString(std::string* out_response_string) const {
   if (core_->response_destination_ != STRING)
     return false;
 
   *out_response_string = core_->data_;
   return true;
 }
 
-void URLFetcher::SetResponseDestinationForTesting(
-    ResponseDestinationType value) {
-  core_->response_destination_ = value;
-}
-
-URLFetcher::ResponseDestinationType
-URLFetcher::GetResponseDestinationForTesting() const {
-  return core_->response_destination_;
-}
-
 bool URLFetcher::GetResponseAsFilePath(bool take_ownership,
                                        FilePath* out_response_path) const {
   DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
   if (core_->response_destination_ != TEMP_FILE ||
       !core_->temp_file_writer_.get())
     return false;
 
   *out_response_path = core_->temp_file_writer_->temp_file();
 
   if (take_ownership) {
     core_->io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::DisownTempFile, core_.get()));
   }
   return true;
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 content::URLFetcherDelegate* URLFetcher::delegate() const {
   return core_->delegate();
 }
+
+// static
+content::URLFetcherFactory* URLFetcher::factory() {
+  return g_factory;
+}
+
+// static
+void URLFetcher::set_factory(content::URLFetcherFactory* factory) {
+  g_factory = factory;
+}