Split to SafeBrowsingDatabaseManager into Local* and Remote*.

chrome/browser/safe_browsing/local_database_manager.cc

 // 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.
 
-#include "chrome/browser/safe_browsing/database_manager.h"
+#include "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 143 matching lines @@
       return SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
       return SB_THREAT_TYPE_SAFE;
   }
 }
 
 }  // namespace
 
 // static
-SBThreatType SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+SBThreatType LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes) {
   return GetThreatTypeFromListType(
       GetHashSeverestThreatListType(hash, full_hashes, NULL));
 }
 
 // static
-SBThreatType SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+SBThreatType LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
     const GURL& url,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   return GetThreatTypeFromListType(
       GetUrlSeverestThreatListType(url, full_hashes, index));
 }
 
-SafeBrowsingDatabaseManager::SafeBrowsingCheck::SafeBrowsingCheck(
+LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::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)
     : urls(urls),
       url_results(urls.size(), SB_THREAT_TYPE_SAFE),
       url_metadata(urls.size()),
       full_hashes(full_hashes),
       full_hash_results(full_hashes.size(), SB_THREAT_TYPE_SAFE),
       client(client),
       need_get_hash(false),
       check_type(check_type),
       expected_threats(expected_threats) {
   DCHECK_EQ(urls.empty(), !full_hashes.empty())
       << "Exactly one of urls and full_hashes must be set";
 }
 
-SafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {}
+LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {
+}
 
-void SafeBrowsingDatabaseManager::Client::OnSafeBrowsingResult(
-    const SafeBrowsingCheck& check) {
+void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
+    OnSafeBrowsingResult() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  DCHECK_EQ(check.urls.size(), check.url_results.size());
-  DCHECK_EQ(check.full_hashes.size(), check.full_hash_results.size());
-  if (!check.urls.empty()) {
-    DCHECK(check.full_hashes.empty());
-    switch (check.check_type) {
+  DCHECK(client);
+  DCHECK_EQ(urls.size(), url_results.size());
+  DCHECK_EQ(full_hashes.size(), full_hash_results.size());
+  if (!urls.empty()) {
+    DCHECK(full_hashes.empty());
+    switch (check_type) {
       case safe_browsing_util::MALWARE:
       case safe_browsing_util::PHISH:
       case safe_browsing_util::UNWANTEDURL:
-        DCHECK_EQ(1u, check.urls.size());
-        OnCheckBrowseUrlResult(
-            check.urls[0], check.url_results[0], check.url_metadata[0]);
+        DCHECK_EQ(1u, urls.size());
+        client->OnCheckBrowseUrlResult(urls[0], url_results[0],
+                                       url_metadata[0]);
         break;
       case safe_browsing_util::BINURL:
-        DCHECK_EQ(check.urls.size(), check.url_results.size());
-        OnCheckDownloadUrlResult(
-            check.urls,
-            *std::max_element(check.url_results.begin(),
-                              check.url_results.end()));
+        DCHECK_EQ(urls.size(), url_results.size());
+        client->OnCheckDownloadUrlResult(
+            urls, *std::max_element(url_results.begin(), url_results.end()));
         break;
       default:
         NOTREACHED();
     }
-  } else if (!check.full_hashes.empty()) {
-    switch (check.check_type) {
+  } else if (!full_hashes.empty()) {
+    switch (check_type) {
       case safe_browsing_util::EXTENSIONBLACKLIST: {
         std::set<std::string> unsafe_extension_ids;
-        for (size_t i = 0; i < check.full_hashes.size(); ++i) {
+        for (size_t i = 0; i < full_hashes.size(); ++i) {
           std::string extension_id =
-              safe_browsing_util::SBFullHashToString(check.full_hashes[i]);
-          if (check.full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
+              safe_browsing_util::SBFullHashToString(full_hashes[i]);
+          if (full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
             unsafe_extension_ids.insert(extension_id);
         }
-        OnCheckExtensionsResult(unsafe_extension_ids);
+        client->OnCheckExtensionsResult(unsafe_extension_ids);
         break;
       }
       default:
         NOTREACHED();
     }
   } else {
     NOTREACHED();
   }
 }
 
-SafeBrowsingDatabaseManager::SafeBrowsingDatabaseManager(
+LocalSafeBrowsingDatabaseManager::LocalSafeBrowsingDatabaseManager(
     const scoped_refptr<SafeBrowsingService>& service)
     : sb_service_(service),
       database_(NULL),
       enabled_(false),
       enable_download_protection_(false),
       enable_csd_whitelist_(false),
       enable_download_whitelist_(false),
       enable_extension_blacklist_(false),
       enable_ip_blacklist_(false),
       enable_unwanted_software_blacklist_(false),
@@ skipping 29 matching lines @@
   // The client-side IP blacklist feature is tightly integrated with client-side
   // phishing protection for now.
   enable_ip_blacklist_ = enable_csd_whitelist_;
 
   // The UwS blacklist feature is controlled by a flag for M40.
   enable_unwanted_software_blacklist_ =
       safe_browsing_util::GetUnwantedTrialGroup() > safe_browsing_util::UWS_OFF;
 #endif
 }
 
-SafeBrowsingDatabaseManager::~SafeBrowsingDatabaseManager() {
+LocalSafeBrowsingDatabaseManager::~LocalSafeBrowsingDatabaseManager() {
   // The DCHECK is disabled due to crbug.com/438754.
   // DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // We should have already been shut down. If we're still enabled, then the
   // database isn't going to be closed properly, which could lead to corruption.
   DCHECK(!enabled_);
 }
 
-bool SafeBrowsingDatabaseManager::CanCheckUrl(const GURL& url) const {
+bool LocalSafeBrowsingDatabaseManager::CanCheckUrl(const GURL& url) const {
   return url.SchemeIs(url::kFtpScheme) ||
          url.SchemeIs(url::kHttpScheme) ||
          url.SchemeIs(url::kHttpsScheme);
 }
 
-bool SafeBrowsingDatabaseManager::CheckDownloadUrl(
+bool LocalSafeBrowsingDatabaseManager::CheckDownloadUrl(
     const std::vector<GURL>& url_chain,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_download_protection_)
     return true;
 
   // We need to check the database for url prefix, and later may fetch the url
   // from the safebrowsing backends. These need to be asynchronous.
   SafeBrowsingCheck* check =
       new SafeBrowsingCheck(url_chain,
                             std::vector<SBFullHash>(),
                             client,
                             safe_browsing_util::BINURL,
                             std::vector<SBThreatType>(1,
                                 SB_THREAT_TYPE_BINARY_MALWARE_URL));
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(url_chain, &prefixes);
   StartSafeBrowsingCheck(
       check,
-      base::Bind(&SafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread, this,
-                 prefixes));
+      base::Bind(&LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread,
+                 this, prefixes));
   return false;
 }
 
-bool SafeBrowsingDatabaseManager::CheckExtensionIDs(
+bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
     const std::set<std::string>& extension_ids,
     Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_ || !enable_extension_blacklist_)
     return true;
 
   std::vector<SBFullHash> extension_id_hashes;
   std::transform(extension_ids.begin(), extension_ids.end(),
                  std::back_inserter(extension_id_hashes),
                  safe_browsing_util::StringToSBFullHash);
   std::vector<SBPrefix> prefixes;
   for (const SBFullHash& hash : extension_id_hashes)
     prefixes.push_back(hash.prefix);
 
   SafeBrowsingCheck* check = new SafeBrowsingCheck(
       std::vector<GURL>(),
       extension_id_hashes,
       client,
       safe_browsing_util::EXTENSIONBLACKLIST,
       std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
       check,
-      base::Bind(&SafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread,
                  this, prefixes));
   return false;
 }
 
-bool SafeBrowsingDatabaseManager::MatchMalwareIP(
+bool LocalSafeBrowsingDatabaseManager::MatchMalwareIP(
     const std::string& ip_address) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_ip_blacklist_ || !MakeDatabaseAvailable()) {
     return false;  // Fail open.
   }
   return database_->ContainsMalwareIP(ip_address);
 }
 
-bool SafeBrowsingDatabaseManager::MatchCsdWhitelistUrl(const GURL& url) {
+bool LocalSafeBrowsingDatabaseManager::MatchCsdWhitelistUrl(const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_csd_whitelist_ || !MakeDatabaseAvailable()) {
     // There is something funky going on here -- for example, perhaps the user
     // has not restarted since enabling metrics reporting, so we haven't
     // enabled the csd whitelist yet.  Just to be safe we return true in this
     // case.
     return true;
   }
   return database_->ContainsCsdWhitelistedUrl(url);
 }
 
-bool SafeBrowsingDatabaseManager::MatchDownloadWhitelistUrl(const GURL& url) {
+bool LocalSafeBrowsingDatabaseManager::MatchDownloadWhitelistUrl(
+    const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_download_whitelist_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->ContainsDownloadWhitelistedUrl(url);
 }
 
-bool SafeBrowsingDatabaseManager::MatchDownloadWhitelistString(
+bool LocalSafeBrowsingDatabaseManager::MatchDownloadWhitelistString(
     const std::string& str) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !enable_download_whitelist_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->ContainsDownloadWhitelistedString(str);
 }
 
-bool SafeBrowsingDatabaseManager::MatchInclusionWhitelistUrl(const GURL& url) {
+bool LocalSafeBrowsingDatabaseManager::MatchInclusionWhitelistUrl(
+    const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !MakeDatabaseAvailable())
     return true;
   return database_->ContainsInclusionWhitelistedUrl(url);
 }
 
-bool SafeBrowsingDatabaseManager::IsMalwareKillSwitchOn() {
+bool LocalSafeBrowsingDatabaseManager::IsMalwareKillSwitchOn() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->IsMalwareIPMatchKillSwitchOn();
 }
 
-bool SafeBrowsingDatabaseManager::IsCsdWhitelistKillSwitchOn() {
+bool LocalSafeBrowsingDatabaseManager::IsCsdWhitelistKillSwitchOn() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->IsCsdWhitelistKillSwitchOn();
 }
 
-bool SafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
+bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
                                                  Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_)
     return true;
 
   if (!CanCheckUrl(url))
     return true;
 
   std::vector<SBThreatType> expected_threats;
   expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
@@ skipping 55 matching lines @@
                                                    client,
                                                    safe_browsing_util::MALWARE,
                                                    expected_threats);
   check->need_get_hash = cache_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->cache_hits.swap(cache_hits);
   checks_.insert(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::OnCheckDone, this, check));
+      base::Bind(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this, check));
 
   return false;
 }
 
-void SafeBrowsingDatabaseManager::CancelCheck(Client* client) {
+void LocalSafeBrowsingDatabaseManager::CancelCheck(Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (CurrentChecks::iterator i = checks_.begin(); i != checks_.end(); ++i) {
     // We can't delete matching checks here because the db thread has a copy of
     // the pointer.  Instead, we simply NULL out the client, and when the db
     // thread calls us back, we'll clean up the check.
     if ((*i)->client == client)
       (*i)->client = NULL;
   }
 
   // Scan the queued clients store. Clients may be here if they requested a URL
   // check before the database has finished loading.
   for (std::deque<QueuedCheck>::iterator it(queued_checks_.begin());
        it != queued_checks_.end(); ) {
     // In this case it's safe to delete matches entirely since nothing has a
     // pointer to them.
     if (it->client == client)
       it = queued_checks_.erase(it);
     else
       ++it;
   }
 }
 
-void SafeBrowsingDatabaseManager::HandleGetHashResults(
+void LocalSafeBrowsingDatabaseManager::HandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes,
     const base::TimeDelta& cache_lifetime) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
 
   // If the service has been shut down, |check| should have been deleted.
   DCHECK(checks_.find(check) != checks_.end());
 
   // |start| is set before calling |GetFullHash()|, which should be
   // the only path which gets to here.
   DCHECK(!check->start.is_null());
   UMA_HISTOGRAM_LONG_TIMES("SB2.Network",
                            base::TimeTicks::Now() - check->start);
 
   std::vector<SBPrefix> prefixes = check->prefix_hits;
   OnHandleGetHashResults(check, full_hashes);  // 'check' is deleted here.
 
   // Cache the GetHash results.
   if (cache_lifetime != base::TimeDelta() && MakeDatabaseAvailable())
     database_->CacheHashResults(prefixes, full_hashes, cache_lifetime);
 }
 
-void SafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
+void LocalSafeBrowsingDatabaseManager::GetChunks(GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::GetAllChunksFromDatabase, this,
-                 callback));
+      base::Bind(&LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase,
+                 this, callback));
 }
 
-void SafeBrowsingDatabaseManager::AddChunks(
+void LocalSafeBrowsingDatabaseManager::AddChunks(
     const std::string& list,
     scoped_ptr<ScopedVector<SBChunkData> > chunks,
     AddChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!callback.is_null());
   safe_browsing_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&SafeBrowsingDatabaseManager::AddDatabaseChunks,
-                            this, list, base::Passed(&chunks), callback));
+      FROM_HERE,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::AddDatabaseChunks, this,
+                 list, base::Passed(&chunks), callback));
 }
 
-void SafeBrowsingDatabaseManager::DeleteChunks(
+void LocalSafeBrowsingDatabaseManager::DeleteChunks(
     scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&SafeBrowsingDatabaseManager::DeleteDatabaseChunks,
-                            this, base::Passed(&chunk_deletes)));
+      FROM_HERE,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks, this,
+                 base::Passed(&chunk_deletes)));
 }
 
-void SafeBrowsingDatabaseManager::UpdateStarted() {
+void LocalSafeBrowsingDatabaseManager::UpdateStarted() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   DCHECK(!update_in_progress_);
   update_in_progress_ = true;
 }
 
-void SafeBrowsingDatabaseManager::UpdateFinished(bool update_succeeded) {
+void LocalSafeBrowsingDatabaseManager::UpdateFinished(bool update_succeeded) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   if (update_in_progress_) {
     update_in_progress_ = false;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&SafeBrowsingDatabaseManager::DatabaseUpdateFinished, this,
-                   update_succeeded));
+        base::Bind(&LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished,
+                   this, update_succeeded));
   }
 }
 
-void SafeBrowsingDatabaseManager::ResetDatabase() {
+void LocalSafeBrowsingDatabaseManager::ResetDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::OnResetDatabase, this));
+      base::Bind(&LocalSafeBrowsingDatabaseManager::OnResetDatabase, this));
 }
 
-void SafeBrowsingDatabaseManager::StartOnIOThread() {
+void LocalSafeBrowsingDatabaseManager::StartOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     return;
 
   // Only get a new task runner if there isn't one already. If the service has
   // previously been started and stopped, a task runner could already exist.
   if (!safe_browsing_task_runner_) {
     base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
     safe_browsing_task_runner_ =
         pool->GetSequencedTaskRunnerWithShutdownBehavior(
             pool->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   }
 
   enabled_ = true;
 
   MakeDatabaseAvailable();
 }
 
-void SafeBrowsingDatabaseManager::StopOnIOThread(bool shutdown) {
+void LocalSafeBrowsingDatabaseManager::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DoStopOnIOThread();
   if (shutdown) {
     sb_service_ = NULL;
   }
 }
 
-void SafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished(
+void LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished(
     bool update_succeeded) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(this),
       content::Details<bool>(&update_succeeded));
 }
 
-SafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
+LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
     const safe_browsing_util::ListType check_type,
     Client* client,
     const GURL& url,
     const std::vector<SBThreatType>& expected_threats,
     const base::TimeTicks& start)
     : check_type(check_type),
       client(client),
       url(url),
       expected_threats(expected_threats),
       start(start) {
 }
 
-SafeBrowsingDatabaseManager::QueuedCheck::~QueuedCheck() {
+LocalSafeBrowsingDatabaseManager::QueuedCheck::~QueuedCheck() {
 }
 
-void SafeBrowsingDatabaseManager::DoStopOnIOThread() {
+void LocalSafeBrowsingDatabaseManager::DoStopOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
 
   enabled_ = false;
 
   // Delete queued checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   while (!queued_checks_.empty()) {
     QueuedCheck queued = queued_checks_.front();
     if (queued.client) {
       SafeBrowsingCheck sb_check(std::vector<GURL>(1, queued.url),
                                  std::vector<SBFullHash>(),
                                  queued.client,
                                  queued.check_type,
                                  queued.expected_threats);
-      queued.client->OnSafeBrowsingResult(sb_check);
+      sb_check.OnSafeBrowsingResult();
     }
     queued_checks_.pop_front();
   }
 
   // Close the database.  Cases to avoid:
   //  * If |closing_database_| is true, continuing will queue up a second
   //    request, |closing_database_| will be reset after handling the first
   //    request, and if any functions on the db thread recreate the database, we
   //    could start using it on the IO thread and then have the second request
   //    handler delete it out from under us.
   //  * If |database_| is NULL, then either no creation request is in flight, in
   //    which case we don't need to do anything, or one is in flight, in which
   //    case the database will be recreated before our deletion request is
   //    handled, and could be used on the IO thread in that time period, leading
   //    to the same problem as above.
   // Checking DatabaseAvailable() avoids both of these.
   if (DatabaseAvailable()) {
     closing_database_ = true;
     safe_browsing_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&SafeBrowsingDatabaseManager::OnCloseDatabase, this));
+        base::Bind(&LocalSafeBrowsingDatabaseManager::OnCloseDatabase, this));
   }
 
   // Delete pending checks, calling back any clients with 'SB_THREAT_TYPE_SAFE'.
   // We have to do this after the db thread returns because methods on it can
   // have copies of these pointers, so deleting them might lead to accessing
   // garbage.
   for (CurrentChecks::iterator it = checks_.begin();
        it != checks_.end(); ++it) {
     SafeBrowsingCheck* check = *it;
     if (check->client)
-      check->client->OnSafeBrowsingResult(*check);
+      check->OnSafeBrowsingResult();
   }
   STLDeleteElements(&checks_);
 
   gethash_requests_.clear();
 }
 
-bool SafeBrowsingDatabaseManager::DatabaseAvailable() const {
+bool LocalSafeBrowsingDatabaseManager::DatabaseAvailable() const {
   base::AutoLock lock(database_lock_);
   return !closing_database_ && (database_ != NULL);
 }
 
-bool SafeBrowsingDatabaseManager::MakeDatabaseAvailable() {
+bool LocalSafeBrowsingDatabaseManager::MakeDatabaseAvailable() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   if (DatabaseAvailable())
     return true;
   safe_browsing_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&SafeBrowsingDatabaseManager::GetDatabase),
-                 this));
+      FROM_HERE, base::Bind(base::IgnoreResult(
+                                &LocalSafeBrowsingDatabaseManager::GetDatabase),
+                            this));
   return false;
 }
 
-SafeBrowsingDatabase* SafeBrowsingDatabaseManager::GetDatabase() {
+SafeBrowsingDatabase* LocalSafeBrowsingDatabaseManager::GetDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   if (database_)
     return database_;
   startup_metric_utils::ScopedSlowStartupUMA
       scoped_timer("Startup.SlowStartupSafeBrowsingGetDatabase");
   const base::TimeTicks before = base::TimeTicks::Now();
 
   SafeBrowsingDatabase* database = SafeBrowsingDatabase::Create(
       safe_browsing_task_runner_, enable_download_protection_,
       enable_csd_whitelist_, enable_download_whitelist_,
       enable_extension_blacklist_, enable_ip_blacklist_,
       enable_unwanted_software_blacklist_);
 
   database->Init(SafeBrowsingService::GetBaseFilename());
   {
     // Acquiring the lock here guarantees correct ordering between the writes to
     // the new database object above, and the setting of |database_| below.
     base::AutoLock lock(database_lock_);
     database_ = database;
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::DatabaseLoadComplete, this));
+      base::Bind(&LocalSafeBrowsingDatabaseManager::DatabaseLoadComplete,
+                 this));
 
   UMA_HISTOGRAM_TIMES("SB2.DatabaseOpen", base::TimeTicks::Now() - before);
   return database_;
 }
 
-void SafeBrowsingDatabaseManager::OnCheckDone(SafeBrowsingCheck* check) {
+void LocalSafeBrowsingDatabaseManager::OnCheckDone(SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
 
   // If the service has been shut down, |check| should have been deleted.
   DCHECK(checks_.find(check) != checks_.end());
 
   if (check->client && check->need_get_hash) {
     // We have a partial match so we need to query Google for the full hash.
@@ skipping 20 matching lines @@
     }
 
     // Reset the start time so that we can measure the network time without the
     // database time.
     check->start = base::TimeTicks::Now();
     // Note: If |this| is deleted or stopped, the protocol_manager will
     // be destroyed as well - hence it's OK to do unretained in this case.
     bool is_download = check->check_type == safe_browsing_util::BINURL;
     sb_service_->protocol_manager()->GetFullHash(
         check->prefix_hits,
-        base::Bind(&SafeBrowsingDatabaseManager::HandleGetHashResults,
+        base::Bind(&LocalSafeBrowsingDatabaseManager::HandleGetHashResults,
                    base::Unretained(this),
                    check),
         is_download);
   } else {
     // We may have cached results for previous GetHash queries.  Since
     // this data comes from cache, don't histogram hits.
     HandleOneCheck(check, check->cache_hits);
   }
 }
 
-void SafeBrowsingDatabaseManager::GetAllChunksFromDatabase(
+void LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase(
     GetChunksCallback callback) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   bool database_error = true;
   std::vector<SBListChunkRanges> lists;
   DCHECK(!database_update_in_progress_);
   database_update_in_progress_ = true;
   GetDatabase();  // This guarantees that |database_| is non-NULL.
   if (database_->UpdateStarted(&lists)) {
     database_error = false;
   } else {
     database_->UpdateFinished(false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase,
                  this, lists, database_error, callback));
 }
 
-void SafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase(
+void LocalSafeBrowsingDatabaseManager::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists, bool database_error,
     GetChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     callback.Run(lists, database_error);
 }
 
-void SafeBrowsingDatabaseManager::OnAddChunksComplete(
+void LocalSafeBrowsingDatabaseManager::OnAddChunksComplete(
     AddChunksCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (enabled_)
     callback.Run();
 }
 
-void SafeBrowsingDatabaseManager::DatabaseLoadComplete() {
+void LocalSafeBrowsingDatabaseManager::DatabaseLoadComplete() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_)
     return;
 
   LOCAL_HISTOGRAM_COUNTS("SB.QueueDepth", queued_checks_.size());
   if (queued_checks_.empty())
     return;
 
   // If the database isn't already available, calling CheckUrl() in the loop
   // below will add the check back to the queue, and we'll infinite-loop.
   DCHECK(DatabaseAvailable());
   while (!queued_checks_.empty()) {
     QueuedCheck check = queued_checks_.front();
     DCHECK(!check.start.is_null());
     LOCAL_HISTOGRAM_TIMES("SB.QueueDelay",
                           base::TimeTicks::Now() - check.start);
     // If CheckUrl() determines the URL is safe immediately, it doesn't call the
     // client's handler function (because normally it's being directly called by
     // the client).  Since we're not the client, we have to convey this result.
     if (check.client && CheckBrowseUrl(check.url, check.client)) {
       SafeBrowsingCheck sb_check(std::vector<GURL>(1, check.url),
                                  std::vector<SBFullHash>(),
                                  check.client,
                                  check.check_type,
                                  check.expected_threats);
-      check.client->OnSafeBrowsingResult(sb_check);
+      sb_check.OnSafeBrowsingResult();
     }
     queued_checks_.pop_front();
   }
 }
 
-void SafeBrowsingDatabaseManager::AddDatabaseChunks(
+void LocalSafeBrowsingDatabaseManager::AddDatabaseChunks(
     const std::string& list_name,
     scoped_ptr<ScopedVector<SBChunkData> > chunks,
     AddChunksCallback callback) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunks)
     GetDatabase()->InsertChunks(list_name, chunks->get());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::OnAddChunksComplete, this,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::OnAddChunksComplete, this,
                  callback));
 }
 
-void SafeBrowsingDatabaseManager::DeleteDatabaseChunks(
+void LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks(
     scoped_ptr<std::vector<SBChunkDelete> > chunk_deletes) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   if (chunk_deletes)
     GetDatabase()->DeleteChunks(*chunk_deletes);
 }
 
-void SafeBrowsingDatabaseManager::DatabaseUpdateFinished(
+void LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished(
     bool update_succeeded) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   GetDatabase()->UpdateFinished(update_succeeded);
   DCHECK(database_update_in_progress_);
   database_update_in_progress_ = false;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished,
-                 this, update_succeeded));
+      base::Bind(
+          &LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished, this,
+          update_succeeded));
 }
 
-void SafeBrowsingDatabaseManager::OnCloseDatabase() {
+void LocalSafeBrowsingDatabaseManager::OnCloseDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(closing_database_);
 
   // Because |closing_database_| is true, nothing on the IO thread will be
   // accessing the database, so it's safe to delete and then NULL the pointer.
   delete database_;
   database_ = NULL;
 
   // Acquiring the lock here guarantees correct ordering between the resetting
   // of |database_| above and of |closing_database_| below, which ensures there
   // won't be a window during which the IO thread falsely believes the database
   // is available.
   base::AutoLock lock(database_lock_);
   closing_database_ = false;
 }
 
-void SafeBrowsingDatabaseManager::OnResetDatabase() {
+void LocalSafeBrowsingDatabaseManager::OnResetDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   GetDatabase()->ResetDatabase();
 }
 
-void SafeBrowsingDatabaseManager::OnHandleGetHashResults(
+void LocalSafeBrowsingDatabaseManager::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   safe_browsing_util::ListType check_type = check->check_type;
   SBPrefix prefix = check->prefix_hits[0];
   GetHashRequests::iterator it = gethash_requests_.find(prefix);
   if (check->prefix_hits.size() > 1 || it == gethash_requests_.end()) {
     const bool hit = HandleOneCheck(check, full_hashes);
     RecordGetHashCheckStatus(hit, check_type, full_hashes);
     return;
   }
 
   // Call back all interested parties, noting if any has a hit.
   GetHashRequestors& requestors = it->second;
   bool hit = false;
   for (GetHashRequestors::iterator r = requestors.begin();
        r != requestors.end(); ++r) {
     if (HandleOneCheck(*r, full_hashes))
       hit = true;
   }
   RecordGetHashCheckStatus(hit, check_type, full_hashes);
 
   gethash_requests_.erase(it);
 }
 
-bool SafeBrowsingDatabaseManager::HandleOneCheck(
+bool LocalSafeBrowsingDatabaseManager::HandleOneCheck(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(check);
 
   bool is_threat = false;
 
   // TODO(shess): GetHashSeverestThreadListType() contains a loop,
   // GetUrlSeverestThreatListType() a loop around that loop.  Having another
   // loop out here concerns me.  It is likely that SAFE is an expected outcome,
@@ skipping 29 matching lines @@
         IsExpectedThreat(threat, check->expected_threats)) {
       check->full_hash_results[i] = threat;
       is_threat = true;
     }
   }
 
   SafeBrowsingCheckDone(check);
   return is_threat;
 }
 
-void SafeBrowsingDatabaseManager::OnAsyncCheckDone(
+void LocalSafeBrowsingDatabaseManager::OnAsyncCheckDone(
     SafeBrowsingCheck* check,
     const std::vector<SBPrefix>& prefix_hits) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enable_download_protection_);
 
   check->prefix_hits = prefix_hits;
   if (check->prefix_hits.empty()) {
     SafeBrowsingCheckDone(check);
   } else {
     check->need_get_hash = true;
     OnCheckDone(check);
   }
 }
 
-std::vector<SBPrefix> SafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread(
+std::vector<SBPrefix>
+LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread(
     const std::vector<SBPrefix>& prefixes) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(enable_download_protection_);
 
   std::vector<SBPrefix> prefix_hits;
   const bool result =
       database_->ContainsDownloadUrlPrefixes(prefixes, &prefix_hits);
   DCHECK_EQ(result, !prefix_hits.empty());
   return prefix_hits;
 }
 
-std::vector<SBPrefix> SafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread(
+std::vector<SBPrefix>
+LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread(
     const std::vector<SBPrefix>& prefixes) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   std::vector<SBPrefix> prefix_hits;
   const bool result =
       database_->ContainsExtensionPrefixes(prefixes, &prefix_hits);
   DCHECK_EQ(result, !prefix_hits.empty());
   return prefix_hits;
 }
 
-void SafeBrowsingDatabaseManager::TimeoutCallback(SafeBrowsingCheck* check) {
+void LocalSafeBrowsingDatabaseManager::TimeoutCallback(
+    SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   DCHECK(checks_.find(check) != checks_.end());
   if (check->client) {
-    check->client->OnSafeBrowsingResult(*check);
+    check->OnSafeBrowsingResult();
     check->client = NULL;
   }
 }
 
-void SafeBrowsingDatabaseManager::SafeBrowsingCheckDone(
+void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheckDone(
     SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   DVLOG(1) << "SafeBrowsingCheckDone";
   DCHECK(checks_.find(check) != checks_.end());
   if (check->client)
-    check->client->OnSafeBrowsingResult(*check);
+    check->OnSafeBrowsingResult();
   checks_.erase(check);
   delete check;
 }
 
-void SafeBrowsingDatabaseManager::StartSafeBrowsingCheck(
+void LocalSafeBrowsingDatabaseManager::StartSafeBrowsingCheck(
     SafeBrowsingCheck* check,
     const base::Callback<std::vector<SBPrefix>(void)>& task) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   check->weak_ptr_factory_.reset(
-      new base::WeakPtrFactory<SafeBrowsingDatabaseManager>(this));
+      new base::WeakPtrFactory<LocalSafeBrowsingDatabaseManager>(this));
   checks_.insert(check);
 
   base::PostTaskAndReplyWithResult(
       safe_browsing_task_runner_.get(), FROM_HERE, task,
-      base::Bind(&SafeBrowsingDatabaseManager::OnAsyncCheckDone,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::OnAsyncCheckDone,
                  check->weak_ptr_factory_->GetWeakPtr(), check));
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      base::Bind(&SafeBrowsingDatabaseManager::TimeoutCallback,
+      base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
                  check->weak_ptr_factory_->GetWeakPtr(), check),
       check_timeout_);
 }
+
+bool LocalSafeBrowsingDatabaseManager::download_protection_enabled() const {
+  return enable_download_protection_;
+}