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

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include <algorithm>
 
@@ skipping 52 matching lines @@
 #error This test requires SAFE_BROWSING_DB_LOCAL.
 #endif
 
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::WebContents;
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::StrictMock;
 
-namespace {
+namespace safe_browsing {
 
 void InvokeFullHashCallback(
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
   callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
 class FakeSafeBrowsingService : public SafeBrowsingService {
  public:
   explicit FakeSafeBrowsingService(const std::string& url_prefix)
@@ skipping 320 matching lines @@
     set_test_result(service_->enabled() == expected_enabled_);
   }
 
  private:
   ~ServiceEnabledHelper() override {}
 
   scoped_refptr<SafeBrowsingService> service_;
   const bool expected_enabled_;
 };
 
-}  // namespace

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

Keep the anon namespace inside the new namespace.

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

Done.

-
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceTest() {
   }
 
   static void GenUrlFullhashResult(const GURL& url,
                                    int list_id,
                                    SBFullHashResult* full_hash) {
     std::string host;
@@ skipping 94 matching lines @@
     return LocalDatabaseManagerForService(sb_service)->check_timeout_;
   }
 
   static void SetCheckTimeout(SafeBrowsingService* sb_service,
                               const base::TimeDelta& delay) {
     LocalDatabaseManagerForService(sb_service)->check_timeout_ = delay;
   }
 
   void CreateCSDService() {
 #if defined(SAFE_BROWSING_CSD)
-    safe_browsing::ClientSideDetectionService* csd_service =
-        safe_browsing::ClientSideDetectionService::Create(NULL);
+    ClientSideDetectionService* csd_service =
+        ClientSideDetectionService::Create(NULL);
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
 
     // A CSD service should already exist.
     EXPECT_TRUE(sb_service->csd_service_);
 
     sb_service->csd_service_.reset(csd_service);
     sb_service->RefreshState();
 #endif
   }
@@ skipping 54 matching lines @@
 class SafeBrowsingServiceMetadataTest
     : public SafeBrowsingServiceTest,
       public ::testing::WithParamInterface<MalwareMetadataTestType> {
  public:
   SafeBrowsingServiceMetadataTest() {}
 
   void GenUrlFullhashResultWithMetadata(const GURL& url,
                                         SBFullHashResult* full_hash) {
     GenUrlFullhashResult(url, safe_browsing::MALWARE, full_hash);
 
-    safe_browsing::MalwarePatternType proto;
+    MalwarePatternType proto;
     switch (GetParam()) {
       case METADATA_NONE:
         full_hash->metadata = std::string();
         break;
       case METADATA_LANDING:
-        proto.set_pattern_type(safe_browsing::MalwarePatternType::LANDING);
+        proto.set_pattern_type(MalwarePatternType::LANDING);
         full_hash->metadata = proto.SerializeAsString();
         break;
       case METADATA_DISTRIBUTION:
-        proto.set_pattern_type(safe_browsing::MalwarePatternType::DISTRIBUTION);
+        proto.set_pattern_type(MalwarePatternType::DISTRIBUTION);
         full_hash->metadata = proto.SerializeAsString();
         break;
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceMetadataTest);
 };
 
 namespace {
@@ skipping 423 matching lines @@
   // There should be a timeout and the hash would be considered as safe.
   EXPECT_EQ(SB_THREAT_TYPE_SAFE, client->GetThreatType());
 
   // Need to set the timeout back to the default value.
   SetCheckTimeout(sb_service, default_urlcheck_timeout);
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, StartAndStop) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  safe_browsing::ClientSideDetectionService* csd_service =
+  ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
 
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
@@ skipping 78 matching lines @@
   }
 
  protected:
   Profile* profile2_;
 };
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceShutdownTest,
                        DontStartAfterShutdown) {
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
-  safe_browsing::ClientSideDetectionService* csd_service =
+  ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
 
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
@@ skipping 183 matching lines @@
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
           sb_service_->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }
+
+}  // namespace safe_browsing