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

chrome/browser/extensions/blacklist.cc

 // Copyright 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/extensions/blacklist.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
  public:
   LazySafeBrowsingDatabaseManager() {
 #if defined(SAFE_BROWSING_DB_LOCAL)
     if (g_browser_process && g_browser_process->safe_browsing_service()) {
       instance_ =
           g_browser_process->safe_browsing_service()->database_manager();
     }
 #endif
   }
 
-  scoped_refptr<SafeBrowsingDatabaseManager> get() {
+  scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> get() {

[Nathan Parker, 2015/11/05 22:00:52]

My opinion: If there are more than 2 or 3 uses in a .cc, I'd put a 
 using safe_browsing::TheClass..;
up top.  Makes the code more readable.

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

Done.

     return instance_;
   }
 
-  void set(scoped_refptr<SafeBrowsingDatabaseManager> instance) {
+  void set(scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> instance) {
     instance_ = instance;
   }
 
  private:
-  scoped_refptr<SafeBrowsingDatabaseManager> instance_;
+  scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> instance_;
 };
 
 static base::LazyInstance<LazySafeBrowsingDatabaseManager> g_database_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 // Implementation of SafeBrowsingDatabaseManager::Client, the class which is
 // called back from safebrowsing queries.
 //
 // Constructed on any thread but lives on the IO from then on.
 class SafeBrowsingClientImpl
-    : public SafeBrowsingDatabaseManager::Client,
+    : public safe_browsing::SafeBrowsingDatabaseManager::Client,
       public base::RefCountedThreadSafe<SafeBrowsingClientImpl> {
  public:
   typedef base::Callback<void(const std::set<std::string>&)> OnResultCallback;
 
   // Constructs a client to query the database manager for |extension_ids| and
   // run |callback| with the IDs of those which have been blacklisted.
   SafeBrowsingClientImpl(
       const std::set<std::string>& extension_ids,
       const OnResultCallback& callback)
       : callback_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         callback_(callback) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeBrowsingClientImpl::StartCheck, this,
                    g_database_manager.Get().get(),
                    extension_ids));
   }
 
  private:
   friend class base::RefCountedThreadSafe<SafeBrowsingClientImpl>;
   ~SafeBrowsingClientImpl() override {}
 
   // Pass |database_manager| as a parameter to avoid touching
   // SafeBrowsingService on the IO thread.
-  void StartCheck(scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
+  void StartCheck(scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager>
+                      database_manager,
                   const std::set<std::string>& extension_ids) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (database_manager->CheckExtensionIDs(extension_ids, this)) {
       // Definitely not blacklisted. Callback immediately.
       callback_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(callback_, std::set<std::string>()));
       return;
     }
     // Something might be blacklisted, response will come in
@@ skipping 38 matching lines @@
 
 Blacklist::Observer::Observer(Blacklist* blacklist) : blacklist_(blacklist) {
   blacklist_->AddObserver(this);
 }
 
 Blacklist::Observer::~Observer() {
   blacklist_->RemoveObserver(this);
 }
 
 Blacklist::ScopedDatabaseManagerForTest::ScopedDatabaseManagerForTest(
-    scoped_refptr<SafeBrowsingDatabaseManager> database_manager)
+    scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager)
     : original_(GetDatabaseManager()) {
   SetDatabaseManager(database_manager);
 }
 
 Blacklist::ScopedDatabaseManagerForTest::~ScopedDatabaseManagerForTest() {
   SetDatabaseManager(original_);
 }
 
 Blacklist::Blacklist(ExtensionPrefs* prefs) {
-  scoped_refptr<SafeBrowsingDatabaseManager> database_manager =
+  scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager =
       g_database_manager.Get().get();
   if (database_manager.get()) {
-    registrar_.Add(
-        this,
-        chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
-        content::Source<SafeBrowsingDatabaseManager>(database_manager.get()));
+    registrar_.Add(this, chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
+                   content::Source<safe_browsing::SafeBrowsingDatabaseManager>(
+                       database_manager.get()));
   }
 
   // Clear out the old prefs-backed blacklist, stored as empty extension entries
   // with just a "blacklisted" property.
   //
   // TODO(kalman): Delete this block of code, see http://crbug.com/295882.
   std::set<std::string> blacklisted = prefs->GetBlacklistedExtensions();
   for (std::set<std::string>::iterator it = blacklisted.begin();
        it != blacklisted.end(); ++it) {
     if (!prefs->GetInstalledExtensionInfo(*it))
@@ skipping 153 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void Blacklist::RemoveObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 // static
 void Blacklist::SetDatabaseManager(
-    scoped_refptr<SafeBrowsingDatabaseManager> database_manager) {
+    scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager>
+        database_manager) {
   g_database_manager.Get().set(database_manager);
 }
 
 // static
-scoped_refptr<SafeBrowsingDatabaseManager> Blacklist::GetDatabaseManager() {
+scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager>
+Blacklist::GetDatabaseManager() {
   return g_database_manager.Get().get();
 }
 
 void Blacklist::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE, type);
   FOR_EACH_OBSERVER(Observer, observers_, OnBlacklistUpdated());
 }
 
 }  // namespace extensions