Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/browser/safe_browsing/protocol_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_
 #pragma once
 
 // A class that implements Chrome's interface with the SafeBrowsing protocol.
 // The SafeBrowsingProtocolManager handles formatting and making requests of,
@@ skipping 18 matching lines @@
 
 namespace net {
 class URLRequestStatus;
 }  // namespace net
 
 #if defined(COMPILER_GCC)
 // Allows us to use URLFetchers in a hash_map with gcc (MSVC is okay without
 // specifying this).
 namespace __gnu_cxx {
 template<>
-struct hash<const URLFetcher*> {
-  size_t operator()(const URLFetcher* fetcher) const {
+struct hash<const content::URLFetcher*> {
+  size_t operator()(const content::URLFetcher* fetcher) const {
     return reinterpret_cast<size_t>(fetcher);
   }
 };
 }
 #endif
 
 class SafeBrowsingProtocolManager;
 // Interface of a factory to create ProtocolManager.  Useful for tests.
 class SBProtocolManagerFactory {
  public:
@@ skipping 45 matching lines @@
       net::URLRequestContextGetter* request_context_getter,
       const std::string& info_url_prefix,
       const std::string& mackey_url_prefix,
       bool disable_auto_update);
 
   // Sets up the update schedule and internal state for making periodic requests
   // of the SafeBrowsing service.
   virtual void Initialize();
 
   // content::URLFetcherDelegate interface.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const content::URLFetcher* source) OVERRIDE;
 
   // API used by the SafeBrowsingService for issuing queries. When the results
   // are available, SafeBrowsingService::HandleGetHashResults is called.
   virtual void GetFullHash(SafeBrowsingService::SafeBrowsingCheck* check,
                            const std::vector<SBPrefix>& prefixes);
 
   // Forces the start of next update after |next_update_msec| in msec.
   void ForceScheduleNextUpdate(int next_update_msec);
 
   // Scheduled update callback.
@@ skipping 187 matching lines @@
   // The factory that controls the creation of SafeBrowsingProtocolManager.
   // This is used by tests.
   static SBProtocolManagerFactory* factory_;
 
   // Main SafeBrowsing interface object.
   SafeBrowsingService* sb_service_;
 
   // Current active request (in case we need to cancel) for updates or chunks
   // from the SafeBrowsing service. We can only have one of these outstanding
   // at any given time unlike GetHash requests, which are tracked separately.
-  scoped_ptr<URLFetcher> request_;
+  scoped_ptr<content::URLFetcher> request_;
 
   // The kind of request that is currently in progress.
   SafeBrowsingRequestType request_type_;
 
   // The number of HTTP response errors, used for request backoff timing.
   int update_error_count_;
   int gethash_error_count_;
 
   // Multipliers which double (max == 8) for each error after the second.
   int update_back_off_mult_;
   int gethash_back_off_mult_;
 
   // Multiplier between 0 and 1 to spread clients over an interval.
   float back_off_fuzz_;
 
   // The list for which we are make a request.
   std::string list_name_;
 
   // For managing the next earliest time to query the SafeBrowsing servers for
   // updates.
   int next_update_sec_;
   base::OneShotTimer<SafeBrowsingProtocolManager> update_timer_;
 
   // All chunk requests that need to be made, along with their MAC.
   std::deque<ChunkUrl> chunk_request_urls_;
 
   // Map of GetHash requests.
-  typedef base::hash_map<const URLFetcher*,
+  typedef base::hash_map<const content::URLFetcher*,
                          SafeBrowsingService::SafeBrowsingCheck*> HashRequests;
   HashRequests hash_requests_;
 
   // The next scheduled update has special behavior for the first 2 requests.
   enum UpdateRequestState {
     FIRST_REQUEST = 0,
     SECOND_REQUEST,
     NORMAL_REQUEST
   };
   UpdateRequestState update_state_;
@@ skipping 21 matching lines @@
   std::string version_;
 
   // Used for measuring chunk request latency.
   base::Time chunk_request_start_;
 
   // Tracks the size of each update (in bytes).
   int update_size_;
 
   // Track outstanding SafeBrowsing report fetchers for clean up.
   // We add both "hit" and "detail" fetchers in this set.
-  std::set<const URLFetcher*> safebrowsing_reports_;
+  std::set<const content::URLFetcher*> safebrowsing_reports_;
 
   // The safe browsing client name sent in each request.
   std::string client_name_;
 
   // A string that is appended to the end of URLs for download, gethash,
   // newkey, safebrowsing hits and chunk update requests.
   std::string additional_query_;
 
   // The context we use to issue network requests.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   // URL prefix where browser fetches safebrowsing chunk updates, hashes, and
   // reports hits to the safebrowsing list for UMA users.
   std::string http_url_prefix_;
 
   // URL prefix where browser fetches MAC client key, and reports detailed
   // malware reports for users who opt-in.
   std::string https_url_prefix_;
 
   // When true, protocol manager will not start an update unless
   // ForceScheduleNextUpdate() is called. This is set for testing purpose.
   bool disable_auto_update_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingProtocolManager);
 };
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PROTOCOL_MANAGER_H_