Split to SafeBrowsingDatabaseManager into Local* and Remote*.

chrome/browser/safe_browsing/local_database_manager.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.
 //
-// The Safe Browsing service is responsible for downloading anti-phishing and
-// anti-malware tables and checking urls against them.
+// Safe Browsing Database Manager implementation that manages a local
+// database.  This is used by Desktop Chromium.
 
-#ifndef CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
-#define CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
+#ifndef CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
+#define CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
+#include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "url/gurl.h"
 
 class SafeBrowsingService;
 class SafeBrowsingDatabase;
 
 namespace net {
 class URLRequestContext;
 class URLRequestContextGetter;
 }
 
 namespace safe_browsing {
 class ClientSideDetectionService;
 class DownloadProtectionService;
 }
 
+// Implemetation that manages a local database on disk.
+//
 // Construction needs to happen on the main thread.
-class SafeBrowsingDatabaseManager
-    : public base::RefCountedThreadSafe<SafeBrowsingDatabaseManager>,
+class LocalSafeBrowsingDatabaseManager
+    : public SafeBrowsingDatabaseManager,
       public SafeBrowsingProtocolManagerDelegate {
  public:
-  class Client;
-
   // Bundle of SafeBrowsing state while performing a URL or hash prefix check.
   struct SafeBrowsingCheck {
     // |check_type| should correspond to the type of item that is being
     // checked, either a URL or a binary hash/URL. We store this for two
     // purposes: to know which of Client's methods to call when a result is
     // known, and for logging purposes. It *isn't* used to predict the response
     // list type, that is information that the server gives us.
     SafeBrowsingCheck(const std::vector<GURL>& urls,
                       const std::vector<SBFullHash>& full_hashes,
                       Client* client,
                       safe_browsing_util::ListType check_type,
                       const std::vector<SBThreatType>& expected_threats);
     ~SafeBrowsingCheck();
 
     // Either |urls| or |full_hashes| is used to lookup database. |*_results|
     // are parallel vectors containing the results. They are initialized to
     // contain SB_THREAT_TYPE_SAFE.
     std::vector<GURL> urls;
     std::vector<SBThreatType> url_results;
     std::vector<std::string> url_metadata;
     std::vector<SBFullHash> full_hashes;
     std::vector<SBThreatType> full_hash_results;
 
-    Client* client;
+    SafeBrowsingDatabaseManager::Client* client;
     bool need_get_hash;
     base::TimeTicks start;  // When check was sent to SB service.
     safe_browsing_util::ListType check_type;  // See comment in constructor.
     std::vector<SBThreatType> expected_threats;
     std::vector<SBPrefix> prefix_hits;
     std::vector<SBFullHashResult> cache_hits;
 
+    // Invoke one of client's callbacks with these results.
+    void OnSafeBrowsingResult();
+
     // Vends weak pointers for async callbacks on the IO thread, such as
     // timeout checks and replies from checks performed on the SB task runner.
     // TODO(lzheng): We should consider to use this time out check
     // for browsing too (instead of implementing in
     // safe_browsing_resource_handler.cc).
-    scoped_ptr<base::WeakPtrFactory<
-        SafeBrowsingDatabaseManager> > weak_ptr_factory_;
+    scoped_ptr<base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>>
+        weak_ptr_factory_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SafeBrowsingCheck);
   };
 
-  class Client {
-   public:
-    void OnSafeBrowsingResult(const SafeBrowsingCheck& check);
-
-   protected:
-    virtual ~Client() {}
-
-    // Called when the result of checking a browse URL is known.
-    virtual void OnCheckBrowseUrlResult(const GURL& url,
-                                        SBThreatType threat_type,
-                                        const std::string& metadata) {}
-
-    // Called when the result of checking a download URL is known.
-    virtual void OnCheckDownloadUrlResult(const std::vector<GURL>& url_chain,
-                                          SBThreatType threat_type) {}
-
-    // Called when the result of checking a set of extensions is known.
-    virtual void OnCheckExtensionsResult(
-        const std::set<std::string>& threats) {}
-  };
-
   // Creates the safe browsing service.  Need to initialize before using.
-  explicit SafeBrowsingDatabaseManager(
+  explicit LocalSafeBrowsingDatabaseManager(
       const scoped_refptr<SafeBrowsingService>& service);
 
-  // Returns true if the url's scheme can be checked.
-  bool CanCheckUrl(const GURL& url) const;
+  //
+  // SafeBrowsingDatabaseManager overrides
+  //
 
-  // Returns whether download protection is enabled.
-  bool download_protection_enabled() const {
-    return enable_download_protection_;
-  }
+  bool CanCheckUrl(const GURL& url) const override;
 
-  // Called on the IO thread to check if the given url is safe or not.  If we
-  // can synchronously determine that the url is safe, CheckUrl returns true.
-  // Otherwise it returns false, and "client" is called asynchronously with the
-  // result when it is ready.
-  virtual bool CheckBrowseUrl(const GURL& url, Client* client);
+  bool CheckBrowseUrl(const GURL& url, Client* client) override;
+  bool CheckDownloadUrl(const std::vector<GURL>& url_chain,
+                        Client* client) override;
+  bool CheckExtensionIDs(const std::set<std::string>& extension_ids,
+                         Client* client) override;
+  bool MatchCsdWhitelistUrl(const GURL& url) override;
+  bool MatchMalwareIP(const std::string& ip_address) override;
+  bool MatchDownloadWhitelistUrl(const GURL& url) override;
+  bool MatchDownloadWhitelistString(const std::string& str) override;
+  bool MatchInclusionWhitelistUrl(const GURL& url) override;
+  bool IsMalwareKillSwitchOn() override;
+  bool IsCsdWhitelistKillSwitchOn() override;
+  void CancelCheck(Client* client) override;
+  void StartOnIOThread() override;
+  void StopOnIOThread(bool shutdown) override;
+  bool download_protection_enabled() const override;
 
-  // Check if the prefix for |url| is in safebrowsing download add lists.
-  // Result will be passed to callback in |client|.
-  virtual bool CheckDownloadUrl(const std::vector<GURL>& url_chain,
-                                Client* client);
+ protected:
+  ~LocalSafeBrowsingDatabaseManager() override;
 
-  // Check which prefixes in |extension_ids| are in the safebrowsing blacklist.
-  // Returns true if not, false if further checks need to be made in which case
-  // the result will be passed to |client|.
-  virtual bool CheckExtensionIDs(const std::set<std::string>& extension_ids,
-                                 Client* client);
+  // protected for tests.
+  void NotifyDatabaseUpdateFinished(bool update_succeeded);
 
-  // Check if the |url| matches any of the full-length hashes from the client-
-  // side phishing detection whitelist.  Returns true if there was a match and
-  // false otherwise.  To make sure we are conservative we will return true if
-  // an error occurs.  This method must be called on the IO thread.
-  virtual bool MatchCsdWhitelistUrl(const GURL& url);
-
-  // Check if the given IP address (either IPv4 or IPv6) matches the malware
-  // IP blacklist.
-  virtual bool MatchMalwareIP(const std::string& ip_address);
-
-  // Check if the |url| matches any of the full-length hashes from the download
-  // whitelist.  Returns true if there was a match and false otherwise. To make
-  // sure we are conservative we will return true if an error occurs.  This
-  // method must be called on the IO thread.
-  virtual bool MatchDownloadWhitelistUrl(const GURL& url);
-
-  // Check if |str| matches any of the full-length hashes from the download
-  // whitelist.  Returns true if there was a match and false otherwise. To make
-  // sure we are conservative we will return true if an error occurs.  This
-  // method must be called on the IO thread.
-  virtual bool MatchDownloadWhitelistString(const std::string& str);
-
-  // Check if the |url| matches any of the full-length hashes from the off-
-  // domain inclusion whitelist. Returns true if there was a match and false
-  // otherwise. To make sure we are conservative, we will return true if an
-  // error occurs.  This method must be called on the IO thread.
-  virtual bool MatchInclusionWhitelistUrl(const GURL& url);
-
-  // Check if the CSD malware IP matching kill switch is turned on.
-  virtual bool IsMalwareKillSwitchOn();
-
-  // Check if the CSD whitelist kill switch is turned on.
-  virtual bool IsCsdWhitelistKillSwitchOn();
-
-  // Called on the IO thread to cancel a pending check if the result is no
-  // longer needed.
-  void CancelCheck(Client* client);
-
+ private:
   // Called on the IO thread when the SafeBrowsingProtocolManager has received
   // the full hash results for prefix hits detected in the database.
   void HandleGetHashResults(SafeBrowsingCheck* check,
                             const std::vector<SBFullHashResult>& full_hashes,
                             const base::TimeDelta& cache_lifetime);
 
-  // Called to initialize objects that are used on the io_thread.  This may be
-  // called multiple times during the life of the DatabaseManager. Must be
-  // called on IO thread.
-  void StartOnIOThread();
-
-  // Called to stop or shutdown operations on the io_thread. This may be called
-  // multiple times during the life of the DatabaseManager. Must be called
-  // on IO thread. If shutdown is true, the manager is disabled permanently.
-  void StopOnIOThread(bool shutdown);
-
- protected:
-  ~SafeBrowsingDatabaseManager() override;
-
-  // protected for tests.
-  void NotifyDatabaseUpdateFinished(bool update_succeeded);
-
- private:
-  friend class base::RefCountedThreadSafe<SafeBrowsingDatabaseManager>;
+  friend class base::RefCountedThreadSafe<LocalSafeBrowsingDatabaseManager>;
   friend class SafeBrowsingServerTest;
   friend class SafeBrowsingServiceTest;
   friend class SafeBrowsingServiceTestHelper;
+  // TODO(nparker): Rename this test to LocalSafeBrowsingDatabaseManagerTest
   friend class SafeBrowsingDatabaseManagerTest;
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            GetUrlSeverestThreatType);
   FRIEND_TEST_ALL_PREFIXES(SafeBrowsingDatabaseManagerTest,
                            ServiceStopWithPendingChecks);
 
   typedef std::set<SafeBrowsingCheck*> CurrentChecks;
   typedef std::vector<SafeBrowsingCheck*> GetHashRequestors;
   typedef base::hash_map<SBPrefix, GetHashRequestors> GetHashRequests;
 
@@ skipping 180 matching lines @@
 
   // Indicates if we're in the midst of trying to close the database.  If this
   // is true, nothing on the IO thread should access the database.
   bool closing_database_;
 
   std::deque<QueuedCheck> queued_checks_;
 
   // Timeout to use for safe browsing checks.
   base::TimeDelta check_timeout_;
 
-  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManager);
-};
+  DISALLOW_COPY_AND_ASSIGN(LocalSafeBrowsingDatabaseManager);
+};  // class LocalSafeBrowsingDatabaseManager
 
-#endif  // CHROME_BROWSER_SAFE_BROWSING_DATABASE_MANAGER_H_
+#endif  // CHROME_BROWSER_SAFE_BROWSING_LOCAL_DATABASE_MANAGER_H_