Remove content::URLFetcherDelegate

chrome/browser/extensions/updater/extension_downloader.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 CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_
 #define CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_
 #pragma once
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
 #include "chrome/browser/extensions/updater/manifest_fetch_data.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/update_manifest.h"
-#include "content/public/common/url_fetcher_delegate.h"
 #include "googleurl/src/gurl.h"
+#include "net/url_request/url_fetcher_delegate.h"
 
 class Version;
 
 namespace net {
+class URLFetcher;
 class URLRequestContextGetter;
 class URLRequestStatus;
 }
 
 namespace extensions {
 
 class ExtensionUpdaterTest;
 
 // A class that checks for updates of a given list of extensions, and downloads
 // the crx file when updates are found. It uses a |ExtensionDownloaderDelegate|
 // that takes ownership of the downloaded crx files, and handles events during
 // the update check.
-class ExtensionDownloader : public content::URLFetcherDelegate {
+class ExtensionDownloader : public net::URLFetcherDelegate {
  public:
   // |delegate| is stored as a raw pointer and must outlive the
   // ExtensionDownloader.
   ExtensionDownloader(ExtensionDownloaderDelegate* delegate,
                       net::URLRequestContextGetter* request_context);
   virtual ~ExtensionDownloader();
 
   // Adds |extension| to the list of extensions to check for updates.
   // Returns false if the |extension| can't be updated due to invalid details.
   // In that case, no callbacks will be performed on the |delegate_|.
@@ skipping 59 matching lines @@
                         Extension::Type extension_type,
                         GURL update_url,
                         const std::string& update_url_data);
 
   // Adds all recorded stats taken so far to histogram counts.
   void ReportStats() const;
 
   // Begins an update check. Takes ownership of |fetch_data|.
   void StartUpdateCheck(ManifestFetchData* fetch_data);
 
-  // content::URLFetcherDelegate implementation.
+  // net::URLFetcherDelegate implementation.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
   // Handles the result of a manifest fetch.
   void OnManifestFetchComplete(const GURL& url,
                                const net::URLRequestStatus& status,
                                int response_code,
                                const std::string& data);
 
   // Once a manifest is parsed, this starts fetches of any relevant crx files.
   // If |results| is null, it means something went wrong when parsing it.
@@ skipping 41 matching lines @@
   URLStats url_stats_;
 
   // List of data on fetches we're going to do. We limit the number of
   // extensions grouped together in one batch to avoid running into the limits
   // on the length of http GET requests, so there might be multiple
   // ManifestFetchData* objects with the same base_url.
   typedef std::map<GURL, std::vector<ManifestFetchData*> > FetchMap;
   FetchMap fetches_preparing_;
 
   // Outstanding url fetch requests for manifests and updates.
-  scoped_ptr<content::URLFetcher> manifest_fetcher_;
-  scoped_ptr<content::URLFetcher> extension_fetcher_;
+  scoped_ptr<net::URLFetcher> manifest_fetcher_;
+  scoped_ptr<net::URLFetcher> extension_fetcher_;
 
   // Pending manifests and extensions to be fetched when the appropriate fetcher
   // is available.
   std::deque<ManifestFetchData*> manifests_pending_;
   std::deque<ExtensionFetch> extensions_pending_;
 
   // The manifest currently being fetched (if any).
   scoped_ptr<ManifestFetchData> current_manifest_fetch_;
 
   // The extension currently being fetched (if any).
   ExtensionFetch current_extension_fetch_;
 
   // Maps an extension-id to its PingResult data.
   std::map<std::string, ExtensionDownloaderDelegate::PingResult> ping_results_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloader);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_