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

chrome/browser/safe_browsing/local_database_manager_unittest.cc

Index: chrome/browser/safe_browsing/local_database_manager_unittest.cc
diff --git a/chrome/browser/safe_browsing/local_database_manager_unittest.cc b/chrome/browser/safe_browsing/local_database_manager_unittest.cc
index b4bbc3056fe7bbef884f5caba63e3513bb7d0253..44ad9552929d89a77d8c1575384bb2a11c570151 100644
--- a/chrome/browser/safe_browsing/local_database_manager_unittest.cc
+++ b/chrome/browser/safe_browsing/local_database_manager_unittest.cc
@@ -18,7 +18,7 @@
 
 using content::TestBrowserThreadBundle;
 
-namespace {
+namespace safe_browsing {
 
 class TestClient : public SafeBrowsingDatabaseManager::Client {
  public:
@@ -36,11 +36,9 @@ class TestClient : public SafeBrowsingDatabaseManager::Client {
   DISALLOW_COPY_AND_ASSIGN(TestClient);
 };
 
-}  // 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.

-
 class SafeBrowsingDatabaseManagerTest : public PlatformTest {
  public:
-  bool RunSBHashTest(const safe_browsing::ListType list_type,
+  bool RunSBHashTest(const ListType list_type,
                      const std::vector<SBThreatType>& expected_threats,
                      const std::string& result_list);
 
@@ -49,7 +47,7 @@ class SafeBrowsingDatabaseManagerTest : public PlatformTest {
 };
 
 bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
-    const safe_browsing::ListType list_type,
+    const ListType list_type,
     const std::vector<SBThreatType>& expected_threats,
     const std::string& result_list) {
   scoped_refptr<SafeBrowsingService> sb_service_(
@@ -60,17 +58,12 @@ bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
 
   LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck* check =
       new LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck(
-          std::vector<GURL>(),
-          std::vector<SBFullHash>(1, same_full_hash),
-          NULL,
-          list_type,
-          expected_threats);
+          std::vector<GURL>(), std::vector<SBFullHash>(1, same_full_hash), NULL,
+          list_type, expected_threats);
   db_manager_->checks_.insert(check);
 
-  const SBFullHashResult full_hash_result = {
-      same_full_hash,
-      safe_browsing::GetListId(result_list)
-  };
+  const SBFullHashResult full_hash_result = {same_full_hash,
+                                             GetListId(result_list)};
 
   std::vector<SBFullHashResult> fake_results(1, full_hash_result);
   bool result = db_manager_->HandleOneCheck(check, fake_results);
@@ -82,23 +75,15 @@ bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
 TEST_F(SafeBrowsingDatabaseManagerTest, CheckCorrespondsListType) {
   std::vector<SBThreatType> malware_threat(1,
                                            SB_THREAT_TYPE_BINARY_MALWARE_URL);
-  EXPECT_FALSE(RunSBHashTest(safe_browsing::BINURL,
-                             malware_threat,
-                             safe_browsing::kMalwareList));
-  EXPECT_TRUE(RunSBHashTest(safe_browsing::BINURL,
-                            malware_threat,
-                            safe_browsing::kBinUrlList));
+  EXPECT_FALSE(RunSBHashTest(BINURL, malware_threat, kMalwareList));
+  EXPECT_TRUE(RunSBHashTest(BINURL, malware_threat, kBinUrlList));
 
   // Check for multiple threats
   std::vector<SBThreatType> multiple_threats;
   multiple_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   multiple_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
-  EXPECT_FALSE(RunSBHashTest(safe_browsing::MALWARE,
-                             multiple_threats,
-                             safe_browsing::kBinUrlList));
-  EXPECT_TRUE(RunSBHashTest(safe_browsing::MALWARE,
-                            multiple_threats,
-                            safe_browsing::kMalwareList));
+  EXPECT_FALSE(RunSBHashTest(MALWARE, multiple_threats, kBinUrlList));
+  EXPECT_TRUE(RunSBHashTest(MALWARE, multiple_threats, kMalwareList));
 }
 
 TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
@@ -111,35 +96,31 @@ TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
       "http://www.unwantedandmalware.com/page.html");
   const GURL kSafeUrl("http://www.safe.com/page.html");
 
-  const SBFullHash kMalwareHostHash =
-      safe_browsing::SBFullHashForString("malware.com/");
-  const SBFullHash kPhishingHostHash =
-      safe_browsing::SBFullHashForString("phishing.com/");
-  const SBFullHash kUnwantedHostHash =
-      safe_browsing::SBFullHashForString("unwanted.com/");
+  const SBFullHash kMalwareHostHash = SBFullHashForString("malware.com/");
+  const SBFullHash kPhishingHostHash = SBFullHashForString("phishing.com/");
+  const SBFullHash kUnwantedHostHash = SBFullHashForString("unwanted.com/");
   const SBFullHash kUnwantedAndMalwareHostHash =
-      safe_browsing::SBFullHashForString("unwantedandmalware.com/");
-  const SBFullHash kSafeHostHash =
-      safe_browsing::SBFullHashForString("www.safe.com/");
+      SBFullHashForString("unwantedandmalware.com/");
+  const SBFullHash kSafeHostHash = SBFullHashForString("www.safe.com/");
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kMalwareHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing::MALWARE);
+    full_hash.list_id = static_cast<int>(MALWARE);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kPhishingHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing::PHISH);
+    full_hash.list_id = static_cast<int>(PHISH);
     full_hashes.push_back(full_hash);
   }
 
   {
     SBFullHashResult full_hash;
     full_hash.hash = kUnwantedHostHash;
-    full_hash.list_id = static_cast<int>(safe_browsing::UNWANTEDURL);
+    full_hash.list_id = static_cast<int>(UNWANTEDURL);
     full_hashes.push_back(full_hash);
   }
 
@@ -148,12 +129,12 @@ TEST_F(SafeBrowsingDatabaseManagerTest, GetUrlSeverestThreatType) {
     // kUnwantedAndMalwareHostHash.
     SBFullHashResult full_hash_malware;
     full_hash_malware.hash = kUnwantedAndMalwareHostHash;
-    full_hash_malware.list_id = static_cast<int>(safe_browsing::MALWARE);
+    full_hash_malware.list_id = static_cast<int>(MALWARE);
     full_hashes.push_back(full_hash_malware);
 
     SBFullHashResult full_hash_unwanted;
     full_hash_unwanted.hash = kUnwantedAndMalwareHostHash;
-    full_hash_unwanted.list_id = static_cast<int>(safe_browsing::UNWANTEDURL);
+    full_hash_unwanted.list_id = static_cast<int>(UNWANTEDURL);
     full_hashes.push_back(full_hash_unwanted);
   }
 
@@ -232,3 +213,5 @@ TEST_F(SafeBrowsingDatabaseManagerTest, ServiceStopWithPendingChecks) {
   content::RunAllBlockingPoolTasksUntilIdle();
   base::RunLoop().RunUntilIdle();
 }
+
+}  // namespace safe_browsing