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

Index: chrome/browser/safe_browsing/local_database_manager.cc
diff --git a/chrome/browser/safe_browsing/local_database_manager.cc b/chrome/browser/safe_browsing/local_database_manager.cc
index 9f23af35b679809ce3e82ce7d2c24d95752670a9..557b8f339149483df9967a68589bdcfeb82c0946 100644
--- a/chrome/browser/safe_browsing/local_database_manager.cc
+++ b/chrome/browser/safe_browsing/local_database_manager.cc
@@ -41,6 +41,10 @@ using content::BrowserThread;
 
 namespace {
 
+using safe_browsing::SBThreatType;
+using safe_browsing::SBFullHashResult;
+using safe_browsing::SafeBrowsingProtocolManager;
+
 // Timeout for match checks, e.g. download URLs, hashes.
 const int kCheckTimeoutMs = 10000;
 
@@ -73,12 +77,12 @@ bool IsExpectedThreat(
 // Return the severest list id from the results in |full_hashes| which matches
 // |hash|, or INVALID if none match.
 safe_browsing::ListType GetHashSeverestThreatListType(
-    const SBFullHash& hash,
+    const safe_browsing::SBFullHash& hash,
     const std::vector<SBFullHashResult>& full_hashes,
     size_t* index) {
   safe_browsing::ListType pending_threat = safe_browsing::INVALID;
   for (size_t i = 0; i < full_hashes.size(); ++i) {
-    if (safe_browsing::SBFullHashEqual(hash, full_hashes[i].hash)) {
+    if (SBFullHashEqual(hash, full_hashes[i].hash)) {
       const safe_browsing::ListType threat =
           static_cast<safe_browsing::ListType>(full_hashes[i].list_id);
       switch (threat) {
@@ -150,26 +154,29 @@ safe_browsing::ListType GetUrlSeverestThreatListType(
   return pending_threat;
 }
 
-SBThreatType GetThreatTypeFromListType(safe_browsing::ListType list_type) {
+safe_browsing::SBThreatType GetThreatTypeFromListType(
+    safe_browsing::ListType list_type) {
   switch (list_type) {
     case safe_browsing::PHISH:
-      return SB_THREAT_TYPE_URL_PHISHING;
+      return safe_browsing::SB_THREAT_TYPE_URL_PHISHING;
     case safe_browsing::MALWARE:
-      return SB_THREAT_TYPE_URL_MALWARE;
+      return safe_browsing::SB_THREAT_TYPE_URL_MALWARE;
     case safe_browsing::UNWANTEDURL:
-      return SB_THREAT_TYPE_URL_UNWANTED;
+      return safe_browsing::SB_THREAT_TYPE_URL_UNWANTED;
     case safe_browsing::BINURL:
-      return SB_THREAT_TYPE_BINARY_MALWARE_URL;
+      return safe_browsing::SB_THREAT_TYPE_BINARY_MALWARE_URL;
     case safe_browsing::EXTENSIONBLACKLIST:
-      return SB_THREAT_TYPE_EXTENSION;
+      return safe_browsing::SB_THREAT_TYPE_EXTENSION;
     default:
       DVLOG(1) << "Unknown safe browsing list id " << list_type;
-      return SB_THREAT_TYPE_SAFE;
+      return safe_browsing::SB_THREAT_TYPE_SAFE;
   }
 }
 
 }  // namespace
 
+namespace safe_browsing {

[Nathan Parker, 2015/11/07 01:15:13]

If you put this up top, and the anonymous namespace within it, then you won't
need the "usings" or the safe_browsing::'s in that anon-namespace.

[vakh (old account. dont use), 2015/11/07 01:22:57]

You mean like this:

namespace safe_browsing {
namespace {
...
}  // namespace
...
}  // namespace safe_browsing


It doesn't seem to work. I get:

../../components/safe_browsing_db/prefix_set.cc:64:7: error: unknown type name
'SBPrefix'; did you mean 'safe_browsing::SBPrefix'?

[Nathan Parker, 2015/11/10 23:53:34]

Really? Hrm, then I've lead you astray. Carry on.

I wonder if this is due to a clang-warning flag of some type, since this works
with plain gcc.  OR, maybe the inner anon-namespace has access only to things in
the same file.  This works w/ gcc:


#include <stdio.h>

namespace foo {
  void a() { printf("a: Hello\n"); }
}

namespace foo {
  namespace {
    void b() { a(); }
  }
  void c() { b(); }
}

int main() {
  foo::c();
  return 0;
}

[mattm, 2015/11/11 01:10:16]

It definitely should work. I noticed prefix_set.cc isn't part of this CL, which
could certainly explain the error. If you try that and continue having trouble,
could you upload the patchset with the problem so we can look at it?

[vakh (old account. dont use), 2015/11/11 18:59:53]

You're right. I have fixed prefix_set.cc and it works now.
Thanks for pointing that out.
Sorry for the confusion.

+
 // static
 SBThreatType LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
     const SBFullHash& hash,
@@ -219,14 +226,14 @@ void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
   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()));
@@ -236,11 +243,11 @@ void LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck::
     }
   } 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);
         }
@@ -339,7 +346,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckDownloadUrl(
       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;
@@ -362,7 +369,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
   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);
@@ -371,7 +378,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckExtensionIDs(
       std::vector<GURL>(),
       extension_id_hashes,
       client,
-      safe_browsing::EXTENSIONBLACKLIST,
+      EXTENSIONBLACKLIST,
       std::vector<SBThreatType>(1, SB_THREAT_TYPE_EXTENSION));
   StartSafeBrowsingCheck(
       check,
@@ -459,7 +466,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
 
   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,
@@ -510,7 +517,7 @@ bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
   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);
@@ -672,7 +679,7 @@ void LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished(
 }
 
 LocalSafeBrowsingDatabaseManager::QueuedCheck::QueuedCheck(
-    const safe_browsing::ListType check_type,
+    const ListType check_type,
     Client* client,
     const GURL& url,
     const std::vector<SBThreatType>& expected_threats,
@@ -872,7 +879,7 @@ void LocalSafeBrowsingDatabaseManager::RequestFullHash(
   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,
@@ -1025,7 +1032,7 @@ 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()) {
@@ -1189,3 +1196,5 @@ void LocalSafeBrowsingDatabaseManager::StartSafeBrowsingCheck(
 bool LocalSafeBrowsingDatabaseManager::download_protection_enabled() const {
   return enable_download_protection_;
 }
+
+}  // namespace safe_browsing