Split to SafeBrowsingDatabaseManager into Local* and Remote*.

chrome/browser/safe_browsing/local_database_manager_unittest.cc

 // Copyright 2013 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 <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
-#include "chrome/browser/safe_browsing/database_manager.h"
+#include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 
 using content::TestBrowserThreadBundle;
 
 namespace {
@@ skipping 25 matching lines @@
  private:
   TestBrowserThreadBundle thread_bundle_;
 };
 
 bool SafeBrowsingDatabaseManagerTest::RunSBHashTest(
     const safe_browsing_util::ListType list_type,
     const std::vector<SBThreatType>& expected_threats,
     const std::string& result_list) {
   scoped_refptr<SafeBrowsingService> sb_service_(
       SafeBrowsingService::CreateSafeBrowsingService());
-  scoped_refptr<SafeBrowsingDatabaseManager> db_manager_(
-      new SafeBrowsingDatabaseManager(sb_service_));
+  scoped_refptr<LocalSafeBrowsingDatabaseManager> db_manager_(
+      new LocalSafeBrowsingDatabaseManager(sb_service_));
   const SBFullHash same_full_hash = {};
 
-  SafeBrowsingDatabaseManager::SafeBrowsingCheck* check =
-      new SafeBrowsingDatabaseManager::SafeBrowsingCheck(
+  LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck* check =
+      new LocalSafeBrowsingDatabaseManager::SafeBrowsingCheck(
           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_util::GetListId(result_list)
@@ skipping 75 matching lines @@
     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_util::UNWANTEDURL);
     full_hashes.push_back(full_hash_unwanted);
   }
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kMalwareHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
-            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kPhishingHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
-            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kUnwantedHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kUnwantedAndMalwareHostHash, full_hashes));
 
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
-            SafeBrowsingDatabaseManager::GetHashSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetHashSeverestThreatType(
                 kSafeHostHash, full_hashes));
 
   const size_t kArbitraryValue = 123456U;
   size_t index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kMalwareUrl, full_hashes, &index));
   EXPECT_EQ(0U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_PHISHING,
-            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kPhishingUrl, full_hashes, &index));
   EXPECT_EQ(1U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_UNWANTED,
-            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kUnwantedUrl, full_hashes, &index));
   EXPECT_EQ(2U, index);
 
   EXPECT_EQ(SB_THREAT_TYPE_URL_MALWARE,
-            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kUnwantedAndMalwareUrl, full_hashes, &index));
   EXPECT_EQ(3U, index);
 
   index = kArbitraryValue;
   EXPECT_EQ(SB_THREAT_TYPE_SAFE,
-            SafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
+            LocalSafeBrowsingDatabaseManager::GetUrlSeverestThreatType(
                 kSafeUrl, full_hashes, &index));
   EXPECT_EQ(kArbitraryValue, index);
 }
 
 TEST_F(SafeBrowsingDatabaseManagerTest, ServiceStopWithPendingChecks) {
   scoped_refptr<SafeBrowsingService> sb_service(
       SafeBrowsingService::CreateSafeBrowsingService());
-  scoped_refptr<SafeBrowsingDatabaseManager> db_manager(
-      new SafeBrowsingDatabaseManager(sb_service));
+  scoped_refptr<LocalSafeBrowsingDatabaseManager> db_manager(
+      new LocalSafeBrowsingDatabaseManager(sb_service));
   TestClient client;
 
   // Start the service and flush tasks to ensure database is made available.
   db_manager->StartOnIOThread();
   content::RunAllBlockingPoolTasksUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(db_manager->DatabaseAvailable());
 
   // Start an extension check operation, which is done asynchronously.
   std::set<std::string> extension_ids;
   extension_ids.insert("testtesttesttesttesttesttesttest");
   db_manager->CheckExtensionIDs(extension_ids, &client);
 
   // Stop the service without first flushing above tasks.
   db_manager->StopOnIOThread(false);
 
   // Now run posted tasks, whish should include the extension check which has
   // been posted to the safe browsing task runner. This should not crash.
   content::RunAllBlockingPoolTasksUntilIdle();
   base::RunLoop().RunUntilIdle();
 }