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 23 matching lines @@
 #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 {
 
+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;
 
 // 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,
     const std::vector<SBFullHashResult>& full_hashes) {
   SafeBrowsingProtocolManager::ResultType result;
@@ skipping 12 matching lines @@
     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(
-    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) {
         case safe_browsing::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.
@@ skipping 51 matching lines @@
       case safe_browsing::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) {
+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,
     const std::vector<SBFullHashResult>& full_hashes) {
   return GetThreatTypeFromListType(
       GetHashSeverestThreatListType(hash, full_hashes, NULL));
 }
 
 // static
 SBThreatType LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
@@ skipping 29 matching lines @@
 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