Convert URLFetcher::Delegates to use an interface in content/public/common. Also remove the old U...

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 "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"
 #include "net/url_request/url_request_throttler_manager.h"
 
 static const int kBufferSize = 4096;
 const int URLFetcher::kInvalidHttpResponseCode = -1;
 
 class URLFetcher::Core
     : public base::RefCountedThreadSafe<URLFetcher::Core>,
       public net::URLRequest::Delegate {
  public:
   // For POST requests, set |content_type| to the MIME type of the content
   // and set |content| to the data to upload.  |flags| are flags to apply to
   // the load operation--these should be one or more of the LOAD_* flags
   // defined in net/base/load_flags.h.
   Core(URLFetcher* fetcher,
        const GURL& original_url,
        RequestType request_type,
-       URLFetcher::Delegate* d);
+       content::URLFetcherDelegate* d);
 
   // Starts the load.  It's important that this not happen in the constructor
   // because it causes the IO thread to begin AddRef()ing and Release()ing
   // us.  If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
   // us, and destroy us, leaving the caller with an already-destroyed object
   // when construction finishes.
   void Start();
 
   // Stops any in-progress load and ensures no callback will happen.  It is
   // safe to call this multiple times.
   void Stop();
 
   // Reports that the received content was malformed (i.e. failed parsing
   // or validation).  This makes the throttling logic that does exponential
   // back-off when servers are having problems treat the current request as
   // a failure.  Your call to this method will be ignored if your request is
   // already considered a failure based on the HTTP response code or response
   // headers.
   void ReceivedContentWasMalformed();
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(net::URLRequest* request);
   virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
 
-  URLFetcher::Delegate* delegate() const { return delegate_; }
+  content::URLFetcherDelegate* delegate() const { return delegate_; }
   static void CancelAll();
 
  private:
   friend class base::RefCountedThreadSafe<URLFetcher::Core>;
 
   class Registry {
    public:
     Registry();
     ~Registry();
 
@@ skipping 129 matching lines @@
   void ReadResponse();
 
   // Drop ownership of any temp file managed by |temp_file_|.
   void DisownTempFile();
 
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   RequestType request_type_;         // What type of request is this?
   net::URLRequestStatus status_;     // Status of the request
-  URLFetcher::Delegate* delegate_;   // Object to notify on completion
+  content::URLFetcherDelegate* delegate_;  // Object to notify on completion
   scoped_refptr<base::MessageLoopProxy> delegate_loop_proxy_;
                                      // Message loop proxy of the creating
                                      // thread.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
                                      // The message loop proxy for the thread
                                      // on which the request IO happens.
   scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
                                      // The message loop proxy for the thread
                                      // on which file access happens.
   scoped_ptr<net::URLRequest> request_;   // The actual request this wraps
@@ skipping 224 matching lines @@
         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;
 
-void URLFetcher::Delegate::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
-  NOTREACHED() << "If you don't implement this, the no-params version "
-               << "should also be implemented, in which case this "
-               << "method won't be called...";
-}
-
-// TODO(skerner): This default implementation will be removed, and the
-// method made pure virtual, once all users of URLFetcher are updated
-// to not expect response data as a string argument.  Once this is removed,
-// the method URLFetcher::GetResponseStringRef() can be removed as well.
-// crbug.com/83592 tracks this.
-void URLFetcher::Delegate::OnURLFetchComplete(const URLFetcher* source) {
-  // A delegate that did not override this method is using the old
-  // parameter list to OnURLFetchComplete(). If a user asked to save
-  // the response to a file, they must use the new parameter list,
-  // in which case we can not get here.
-  // To avoid updating all callers, thunk to the old prototype for now.
-  OnURLFetchComplete(source,
-                     source->url(),
-                     source->status(),
-                     source->response_code(),
-                     source->cookies(),
-                     source->GetResponseStringRef());
-}
-
 // static
 bool URLFetcher::g_interception_enabled = false;
 
 URLFetcher::URLFetcher(const GURL& url,
                        RequestType request_type,
-                       Delegate* d)
+                       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, Delegate* d) {
+                               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,
-                       URLFetcher::Delegate* d)
+                       content::URLFetcherDelegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::current()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(URLFetcher::kInvalidHttpResponseCode),
       buffer_(new net::IOBuffer(kBufferSize)),
@@ skipping 46 matching lines @@
       // Core::StartURLRequestWhenAppropriate() will be called.
       temp_file_writer_->CreateTempFile();
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void URLFetcher::Core::Stop() {
-  DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
+  if (delegate_loop_proxy_) {  // May be NULL in tests.
+    DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
+  }
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::CancelURLRequest, this));
   }
 }
 
 void URLFetcher::Core::ReceivedContentWasMalformed() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
@@ skipping 473 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;
 }
 
-const std::string& URLFetcher::GetResponseStringRef() const {
-  CHECK(core_->response_destination_ == STRING);
-  return core_->data_;
-}
-
 void URLFetcher::SetResponseDestinationForTesting(
     ResponseDestinationType value) {
   core_->response_destination_ = value;
 }
 
 URLFetcher::ResponseDestinationType
 URLFetcher::GetResponseDestinationForTesting() const {
   return core_->response_destination_;
 }
 
@@ skipping 16 matching lines @@
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
-URLFetcher::Delegate* URLFetcher::delegate() const {
+content::URLFetcherDelegate* URLFetcher::delegate() const {
   return core_->delegate();
 }