Move code in components/safe_browsing_db and chrome/browser/s_b/ under the safe_browsing namespace.

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/local_database_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 21 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/safe_browsing_db/util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "url/url_constants.h"
 
 using content::BrowserThread;
 
-namespace {
+namespace safe_browsing {
 
 // Timeout for match checks, e.g. download URLs, hashes.
 const int kCheckTimeoutMs = 10000;
 
 // Records disposition information about the check.  |hit| should be
 // |true| if there were any prefix hits in |full_hashes|.
 void RecordGetHashCheckStatus(
     bool hit,
-    safe_browsing::ListType check_type,
+    ListType check_type,
     const std::vector<SBFullHashResult>& full_hashes) {
   SafeBrowsingProtocolManager::ResultType result;
   if (full_hashes.empty()) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_EMPTY;
   } else if (hit) {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_HIT;
   } else {
     result = SafeBrowsingProtocolManager::GET_HASH_FULL_HASH_MISS;
   }
-  bool is_download = check_type == safe_browsing::BINURL;
+  bool is_download = check_type == BINURL;
   SafeBrowsingProtocolManager::RecordGetHashResult(is_download, result);
 }
 
 bool IsExpectedThreat(
     const SBThreatType threat_type,
     const std::vector<SBThreatType>& expected_threats) {
   return expected_threats.end() != std::find(expected_threats.begin(),
                                              expected_threats.end(),
                                              threat_type);
 }
 
 // Return the severest list id from the results in |full_hashes| which matches
 // |hash|, or INVALID if none match.
-safe_browsing::ListType GetHashSeverestThreatListType(
+ListType GetHashSeverestThreatListType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
-  safe_browsing::ListType pending_threat = safe_browsing::INVALID;
+  ListType pending_threat = INVALID;
   for (size_t i = 0; i < full_hashes.size(); ++i) {
-    if (safe_browsing::SBFullHashEqual(hash, full_hashes[i].hash)) {
-      const safe_browsing::ListType threat =
-          static_cast<safe_browsing::ListType>(full_hashes[i].list_id);
+    if (SBFullHashEqual(hash, full_hashes[i].hash)) {
+      const ListType threat =
+          static_cast<ListType>(full_hashes[i].list_id);
       switch (threat) {
-        case safe_browsing::INVALID:
+        case INVALID:
           // |full_hashes| should never contain INVALID as a |list_id|.
           NOTREACHED();
           break;
-        case safe_browsing::MALWARE:                  // Falls through.
-        case safe_browsing::PHISH:                    // Falls through.
-        case safe_browsing::BINURL:                   // Falls through.
-        case safe_browsing::CSDWHITELIST:             // Falls through.
-        case safe_browsing::DOWNLOADWHITELIST:        // Falls through.
-        case safe_browsing::INCLUSIONWHITELIST:       // Falls through.
-        case safe_browsing::EXTENSIONBLACKLIST:       // Falls through.
-        case safe_browsing::IPBLACKLIST:
+        case MALWARE:                  // Falls through.
+        case PHISH:                    // Falls through.
+        case BINURL:                   // Falls through.
+        case CSDWHITELIST:             // Falls through.
+        case DOWNLOADWHITELIST:        // Falls through.
+        case INCLUSIONWHITELIST:       // Falls through.
+        case EXTENSIONBLACKLIST:       // Falls through.
+        case IPBLACKLIST:
           if (index)
             *index = i;
           return threat;
-        case safe_browsing::UNWANTEDURL:
+        case UNWANTEDURL:
           // UNWANTEDURL is considered less severe than other threats, keep
           // looking.
           pending_threat = threat;
           if (index)
             *index = i;
           break;
       }
     }
   }
   return pending_threat;
 }
 
 // Given a URL, compare all the possible host + path full hashes to the set of
 // provided full hashes.  Returns the list id of the severest matching result
 // from |full_hashes|, or INVALID if none match.
-safe_browsing::ListType GetUrlSeverestThreatListType(
+ListType GetUrlSeverestThreatListType(
     const GURL& url,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   if (full_hashes.empty())
-    return safe_browsing::INVALID;
+    return INVALID;
 
   std::vector<std::string> patterns;
-  safe_browsing::GeneratePatternsToCheck(url, &patterns);
+  GeneratePatternsToCheck(url, &patterns);
 
-  safe_browsing::ListType pending_threat = safe_browsing::INVALID;
+  ListType pending_threat = INVALID;
   for (size_t i = 0; i < patterns.size(); ++i) {
-    safe_browsing::ListType threat = GetHashSeverestThreatListType(
-        safe_browsing::SBFullHashForString(patterns[i]), full_hashes, index);
+    ListType threat = GetHashSeverestThreatListType(
+        SBFullHashForString(patterns[i]), full_hashes, index);
     switch (threat) {
-      case safe_browsing::INVALID:
+      case INVALID:
         // Ignore patterns with no matching threat.
         break;
-      case safe_browsing::MALWARE:                  // Falls through.
-      case safe_browsing::PHISH:                    // Falls through.
-      case safe_browsing::BINURL:                   // Falls through.
-      case safe_browsing::CSDWHITELIST:             // Falls through.
-      case safe_browsing::DOWNLOADWHITELIST:        // Falls through.
-      case safe_browsing::INCLUSIONWHITELIST:       // Falls through.
-      case safe_browsing::EXTENSIONBLACKLIST:       // Falls through.
-      case safe_browsing::IPBLACKLIST:
+      case MALWARE:                  // Falls through.
+      case PHISH:                    // Falls through.
+      case BINURL:                   // Falls through.
+      case CSDWHITELIST:             // Falls through.
+      case DOWNLOADWHITELIST:        // Falls through.
+      case INCLUSIONWHITELIST:       // Falls through.
+      case EXTENSIONBLACKLIST:       // Falls through.
+      case IPBLACKLIST:
         return threat;
-      case safe_browsing::UNWANTEDURL:
+      case UNWANTEDURL:
         // UNWANTEDURL is considered less severe than other threats, keep
         // looking.
         pending_threat = threat;
         break;
     }
   }
   return pending_threat;
 }
 
-SBThreatType GetThreatTypeFromListType(safe_browsing::ListType list_type) {
+SBThreatType GetThreatTypeFromListType(ListType list_type) {
   switch (list_type) {
-    case safe_browsing::PHISH:
+    case PHISH:
       return SB_THREAT_TYPE_URL_PHISHING;
-    case safe_browsing::MALWARE:
+    case MALWARE:
       return SB_THREAT_TYPE_URL_MALWARE;
-    case safe_browsing::UNWANTEDURL:
+    case UNWANTEDURL:
       return SB_THREAT_TYPE_URL_UNWANTED;
-    case safe_browsing::BINURL:
+    case BINURL:
       return SB_THREAT_TYPE_BINARY_MALWARE_URL;
-    case safe_browsing::EXTENSIONBLACKLIST:
+    case EXTENSIONBLACKLIST:
       return SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
       return SB_THREAT_TYPE_SAFE;
   }
 }
 
-}  // namespace
-
 // static
 SBThreatType LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
     const SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes) {
   return GetThreatTypeFromListType(
       GetHashSeverestThreatListType(hash, full_hashes, NULL));
 }
 
 // static
 SBThreatType LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
     const GURL& url,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   return GetThreatTypeFromListType(
       GetUrlSeverestThreatListType(url, full_hashes, index));
 }
 
 LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::SafeBrowsingCheck(
     const std::vector<GURL>& urls,
     const std::vector<SBFullHash>& full_hashes,
     Client* client,
-    safe_browsing::ListType check_type,
+    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";
 }
 
 LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::~SafeBrowsingCheck() {
 }
 
 void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
     OnSafeBrowsingResult() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   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::MALWARE:
-      case safe_browsing::PHISH:
-      case safe_browsing::UNWANTEDURL:
+      case MALWARE:
+      case PHISH:
+      case UNWANTEDURL:
         DCHECK_EQ(1u, urls.size());
         client->OnCheckBrowseUrlResult(urls[0], url_results[0],
                                        url_metadata[0]);
         break;
-      case safe_browsing::BINURL:
+      case BINURL:
         DCHECK_EQ(urls.size(), url_results.size());
         client->OnCheckDownloadUrlResult(
             urls, *std::max_element(url_results.begin(), url_results.end()));
         break;
       default:
         NOTREACHED();
     }
   } else if (!full_hashes.empty()) {
     switch (check_type) {
-      case safe_browsing::EXTENSIONBLACKLIST: {
+      case EXTENSIONBLACKLIST: {
         std::set<std::string> unsafe_extension_ids;
         for (size_t i = 0; i < full_hashes.size(); ++i) {
           std::string extension_id =
-              safe_browsing::SBFullHashToString(full_hashes[i]);
+              SBFullHashToString(full_hashes[i]);
           if (full_hash_results[i] == SB_THREAT_TYPE_EXTENSION)
             unsafe_extension_ids.insert(extension_id);
         }
         client->OnCheckExtensionsResult(unsafe_extension_ids);
         break;
       }
       default:
         NOTREACHED();
     }
   } else {
@@ skipping 78 matching lines @@
   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::BINURL,
+                            BINURL,
                             std::vector<SBThreatType>(1,
                                 SB_THREAT_TYPE_BINARY_MALWARE_URL));
   std::vector<SBPrefix> prefixes;
   SafeBrowsingDatabase::GetDownloadUrlPrefixes(url_chain, &prefixes);
   StartSafeBrowsingCheck(
       check,
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread,
                  this, prefixes));
   return false;
 }
 
 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::StringToSBFullHash);
+                 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::EXTENSIONBLACKLIST,
+      EXTENSIONBLACKLIST,
       std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
       check,
       base::Bind(&LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread,
                  this, prefixes));
   return false;
 }
 
 bool LocalSafeBrowsingDatabaseManager::MatchMalwareIP(
     const std::string& ip_address) {
@@ skipping 67 matching lines @@
   if (!CanCheckUrl(url))
     return true;
 
   std::vector<SBThreatType> expected_threats;
   expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
   expected_threats.push_back(SB_THREAT_TYPE_URL_UNWANTED);
 
   const base::TimeTicks start = base::TimeTicks::Now();
   if (!MakeDatabaseAvailable()) {
-    QueuedCheck queued_check(safe_browsing::MALWARE,  // or PHISH
+    QueuedCheck queued_check(MALWARE,  // or PHISH
                              client,
                              url,
                              expected_threats,
                              start);
     queued_checks_.push_back(queued_check);
     return false;
   }
 
   // Cache hits should, in general, be the same for both (ignoring potential
   // cache evictions in the second call for entries that were just about to be
@@ skipping 30 matching lines @@
 
   // Needs to be asynchronous, since we could be in the constructor of a
   // ResourceDispatcherHost event handler which can't pause there.
   // This check will ping the Safe Browsing servers and get all lists which it
   // matches. These lists will then be filtered against the |expected_threats|
   // and the result callback for MALWARE (which is the same as for PHISH and
   // UNWANTEDURL) will eventually be invoked with the final decision.
   SafeBrowsingCheck* check = new SafeBrowsingCheck(std::vector<GURL>(1, url),
                                                    std::vector<SBFullHash>(),
                                                    client,
-                                                   safe_browsing::MALWARE,
+                                                   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(&LocalSafeBrowsingDatabaseManager::OnCheckDone, this, check));
 
@@ skipping 141 matching lines @@
 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));
 }
 
 LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
-    const safe_browsing::ListType check_type,
+    const 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) {
 }
@@ skipping 179 matching lines @@
   return is_extended_reporting;
 }
 
 void LocalSafeBrowsingDatabaseManager::RequestFullHash(
     SafeBrowsingCheck* check) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!enabled_)
     return;
 
-  bool is_download = check->check_type == safe_browsing::BINURL;
+  bool is_download = check->check_type == BINURL;
   sb_service_->protocol_manager()->GetFullHash(
       check->prefix_hits,
       base::Bind(&LocalSafeBrowsingDatabaseManager::HandleGetHashResults,
                  base::Unretained(this), check),
       is_download, check->is_extended_reporting);
 }
 
 void LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase(
     GetChunksCallback callback) {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 132 matching lines @@
 void LocalSafeBrowsingDatabaseManager::OnResetDatabase() {
   DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
 
   GetDatabase()->ResetDatabase();
 }
 
 void LocalSafeBrowsingDatabaseManager::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  safe_browsing::ListType check_type = check->check_type;
+  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;
@@ skipping 143 matching lines @@
                  check->weak_ptr_factory_->GetWeakPtr(), check));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
                             check->weak_ptr_factory_->GetWeakPtr(), check),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::download_protection_enabled() const {
   return enable_download_protection_;
 }
+
+}  // namespace safe_browsing