Add a browser test for safebrowsing service....

chrome/browser/safe_browsing/protocol_manager.h

 // Copyright (c) 2010 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 24 matching lines @@
 namespace __gnu_cxx {
 template<>
 struct hash<const URLFetcher*> {
   size_t operator()(const 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:
+  SBProtocolManagerFactory() {}
+  virtual ~SBProtocolManagerFactory() {}
+  virtual SafeBrowsingProtocolManager* CreateProtocolManager(
+      SafeBrowsingService* sb_service,
+      const std::string& client_name,
+      const std::string& client_key,
+      const std::string& wrapped_key,
+      URLRequestContextGetter* request_context_getter,
+      const std::string& info_url_prefix,
+      const std::string& mackey_url_prefix,
+      bool disable_auto_update) = 0;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SBProtocolManagerFactory);
+};
+
 class SafeBrowsingProtocolManager : public URLFetcher::Delegate {
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestBackOffTimes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestChunkStrings);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestGetHashUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestGetHashBackOffTimes);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestMacKeyUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestSafeBrowsingHitUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest,
                            TestMalwareDetailsUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestNextChunkUrl);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingProtocolManagerTest, TestUpdateUrl);
   friend class SafeBrowsingServiceTest;
 
  public:
-  // Constructs a SafeBrowsingProtocolManager for |sb_service| that issues
-  // network requests using |request_context_getter|. When |disable_auto_update|
-  // is true, protocol manager won't schedule next update until
-  // ForceScheduleNextUpdate is called.
-  SafeBrowsingProtocolManager(SafeBrowsingService* sb_service,
-                              const std::string& client_name,
-                              const std::string& client_key,
-                              const std::string& wrapped_key,
-                              URLRequestContextGetter* request_context_getter,
-                              const std::string& http_url_prefix,
-                              const std::string& https_url_prefix,
-                              bool disable_auto_update);
   virtual ~SafeBrowsingProtocolManager();
 
+  // Makes the passed |factory| the factory used to instantiate
+  // a SafeBrowsingService. Useful for tests.
+  static void RegisterFactory(SBProtocolManagerFactory* factory) {
+    factory_ = factory;
+  }
+
+  // Create an instance of the safe browsing service.
+  static SafeBrowsingProtocolManager* Create(
+      SafeBrowsingService* sb_service,
+      const std::string& client_name,
+      const std::string& client_key,
+      const std::string& wrapped_key,
+      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.
-  void Initialize();
+  virtual void Initialize();
 
   // URLFetcher::Delegate interface.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
   // API used by the SafeBrowsingService for issuing queries. When the results
   // are available, SafeBrowsingService::HandleGetHashResults is called.
-  void GetFullHash(SafeBrowsingService::SafeBrowsingCheck* check,
-                   const std::vector<SBPrefix>& prefixes);
+  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);
 
-  bool is_initial_request() const { return initial_request_; }
-
   // Scheduled update callback.
   void GetNextUpdate();
 
   // Called by the SafeBrowsingService when our request for a list of all chunks
   // for each list is done.  If database_error is true, that means the protocol
   // manager shouldn't fetch updates since they can't be written to disk.  It
   // should try again later to open the database.
   void OnGetChunksComplete(const std::vector<SBListChunkRanges>& list,
                            bool database_error);
 
   // Called after the chunks that were parsed were inserted in the database.
   void OnChunkInserted();
 
-  // The last time we received an update.
-  base::Time last_update() const { return last_update_; }
-
   // For UMA users we report to Google when a SafeBrowsing interstitial is shown
   // to the user.  We assume that the threat type is either URL_MALWARE or
   // URL_PHISHING.
   void ReportSafeBrowsingHit(const GURL& malicious_url,
                              const GURL& page_url,
                              const GURL& referrer_url,
                              bool is_subresource,
                              SafeBrowsingService::UrlCheckResult threat_type);
 
   // Users can opt-in on the SafeBrowsing interstitial to send detailed
   // malware reports. |report| is the serialized report.
   void ReportMalwareDetails(const std::string& report);
 
+  bool is_initial_request() const { return initial_request_; }
+
+  // The last time we received an update.
+  base::Time last_update() const { return last_update_; }
+
   // Setter for additional_query_. To make sure the additional_query_ won't
   // be changed in the middle of an update, caller (e.g.: SafeBrowsingService)
   // should call this after callbacks triggered in UpdateFinished() or before
   // IssueUpdateRequest().
   void set_additional_query(const std::string& query) {
     additional_query_ = query;
   }
   const std::string& additional_query() const {
     return additional_query_;
   }
 
+ protected:
+  // Constructs a SafeBrowsingProtocolManager for |sb_service| that issues
+  // network requests using |request_context_getter|. When |disable_auto_update|
+  // is true, protocol manager won't schedule next update until
+  // ForceScheduleNextUpdate is called.
+  SafeBrowsingProtocolManager(SafeBrowsingService* sb_service,
+                              const std::string& client_name,
+                              const std::string& client_key,
+                              const std::string& wrapped_key,
+                              URLRequestContextGetter* request_context_getter,
+                              const std::string& http_url_prefix,
+                              const std::string& https_url_prefix,
+                              bool disable_auto_update);
  private:
+  friend class SBProtocolManagerFactoryImpl;
+
   // Internal API for fetching information from the SafeBrowsing servers. The
   // GetHash requests are higher priority since they can block user requests
   // so are handled separately.
   enum SafeBrowsingRequestType {
     NO_REQUEST = 0,     // No requests in progress
     UPDATE_REQUEST,     // Request for redirect URLs
     CHUNK_REQUEST,      // Request for a specific chunk
     GETKEY_REQUEST      // Update the client's MAC key
   };
 
@@ skipping 75 matching lines @@
   void HandleGetHashError(const base::Time& now);
 
   // Helper function for update completion.
   void UpdateFinished(bool success);
 
   // A callback that runs if we timeout waiting for a response to an update
   // request. We use this to properly set our update state.
   void UpdateResponseTimeout();
 
  private:
+  // 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_;
 
   // The kind of request that is currently in progress.
   SafeBrowsingRequestType request_type_;
@@ skipping 84 matching lines @@
   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_