Remove content::URLFetcherDelegate

content/common/net/url_fetcher_core.h

 // 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.
 
 #ifndef CONTENT_COMMON_NET_URL_FETCHER_CORE_H_
 #define CONTENT_COMMON_NET_URL_FETCHER_CORE_H_
 #pragma once
 
 #include <set>
 #include <string>
@@ skipping 16 matching lines @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace base {
 class MessageLoopProxy;
 }  // namespace base
 
 namespace net {
 class HttpResponseHeaders;
 class IOBuffer;
+class URLFetcherDelegate;
 class URLRequestContextGetter;
 class URLRequestThrottlerEntryInterface;
 }  // namespace net
 
 namespace content {
 
-class URLFetcherDelegate;
-
 class URLFetcherCore
     : public base::RefCountedThreadSafe<URLFetcherCore>,
       public net::URLRequest::Delegate {
  public:
   URLFetcherCore(URLFetcher* fetcher,
                  const GURL& original_url,
                  URLFetcher::RequestType request_type,
-                 URLFetcherDelegate* d);
+                 net::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
@@ skipping 55 matching lines @@
   bool GetResponseAsString(std::string* out_response_string) const;
   bool GetResponseAsFilePath(bool take_ownership,
                              FilePath* out_response_path);
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(
       net::URLRequest* request) OVERRIDE;
   virtual void OnReadCompleted(
       net::URLRequest* request, int bytes_read) OVERRIDE;
 
-  URLFetcherDelegate* delegate() const { return delegate_; }
+  net::URLFetcherDelegate* delegate() const { return delegate_; }
   static void CancelAll();
   static int GetNumFetcherCores();
   static void SetEnableInterceptionForTests(bool enabled);
 
  private:
   friend class base::RefCountedThreadSafe<URLFetcherCore>;
 
   // How should the response be stored?
   enum ResponseDestinationType {
     STRING,  // Default: In a std::string
@@ skipping 154 matching lines @@
                                                       int64 total);
   void InformDelegateDownloadDataIfNecessary(int bytes_read);
   void InformDelegateDownloadDataInDelegateThread(
       scoped_ptr<std::string> download_data);
 
   URLFetcher* fetcher_;              // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   URLFetcher::RequestType request_type_;  // What type of request is this?
   net::URLRequestStatus status_;     // Status of the request
-  URLFetcherDelegate* delegate_;     // Object to notify on completion
+  net::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 82 matching lines @@
   base::debug::StackTrace stack_trace_;
 
   static base::LazyInstance<Registry> g_registry;
 
   DISALLOW_COPY_AND_ASSIGN(URLFetcherCore);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_NET_URL_FETCHER_CORE_H_