Split to SafeBrowsingDatabaseManager into Local* and Remote*.

chrome/browser/safe_browsing/safe_browsing_test.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 uses the safebrowsing test server published at
 // http://code.google.com/p/google-safe-browsing/ to test the safebrowsing
 // protocol implemetation. Details of the safebrowsing testing flow is
 // documented at
 // http://code.google.com/p/google-safe-browsing/wiki/ProtocolTesting
 //
@@ skipping 15 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
+#include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/local_safebrowsing_test_server.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/load_flags.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/test/python_utils.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
+#ifndef SAFE_BROWSING_DB_LOCAL
+#error This test requires the SAFE_BROWSING_DB_LOCAL implementation.
+#endif
+
 namespace {
 
 const base::FilePath::CharType kDataFile[] =
     FILE_PATH_LITERAL("testing_input_nomac.dat");
 const char kUrlVerifyPath[] = "safebrowsing/verify_urls";
 const char kDBVerifyPath[] = "safebrowsing/verify_database";
 const char kTestCompletePath[] = "test_complete";
 
 struct PhishingUrl {
   std::string url;
@@ skipping 113 matching lines @@
     observer.Wait();
   }
 
   void ForceUpdateOnIOThread() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ASSERT_TRUE(safe_browsing_service_);
     safe_browsing_service_->protocol_manager_->ForceScheduleNextUpdate(
         base::TimeDelta::FromSeconds(0));
   }
 
+
   void CheckIsDatabaseReady() {
     base::AutoLock lock(update_status_mutex_);
-    is_database_ready_ = !database_manager()->database_update_in_progress_;
+    is_database_ready_ =
+        !local_database_manager()->database_update_in_progress_;
   }
 
   void CheckUrl(SafeBrowsingDatabaseManager::Client* helper, const GURL& url) {
     ASSERT_TRUE(safe_browsing_service_);
     base::AutoLock lock(update_status_mutex_);
     if (database_manager()->CheckBrowseUrl(url, helper)) {
       is_checked_url_in_db_ = false;
       is_checked_url_safe_ = true;
     } else {
       // In this case, Safebrowsing service will fetch the full hash
       // from the server and examine that. Once it is done,
       // set_is_checked_url_safe() will be called via callback.
       is_checked_url_in_db_ = true;
     }
   }
 
   SafeBrowsingDatabaseManager* database_manager() {
     return safe_browsing_service_->database_manager().get();
   }
 
+  // TODO(nparker): Remove the need for this by wiring in our own
+  // SafeBrowsingDatabaseManager factory and keep a ptr to the subclass.
+  LocalSafeBrowsingDatabaseManager* local_database_manager() {
+    return static_cast<LocalSafeBrowsingDatabaseManager*>(database_manager());
+  }
+
+
   bool is_checked_url_in_db() {
     base::AutoLock l(update_status_mutex_);
     return is_checked_url_in_db_;
   }
 
   void set_is_checked_url_safe(bool safe) {
     base::AutoLock l(update_status_mutex_);
     is_checked_url_safe_ = safe;
   }
 
@@ skipping 11 matching lines @@
     base::AutoLock l(update_status_mutex_);
     return last_update_;
   }
 
   bool is_update_scheduled() {
     base::AutoLock l(update_status_mutex_);
     return is_update_scheduled_;
   }
 
   scoped_refptr<base::SequencedTaskRunner> SafeBrowsingTaskRunner() {
-    return database_manager()->safe_browsing_task_runner_;
+    return local_database_manager()->safe_browsing_task_runner_;
   }
 
   const net::SpawnedTestServer& test_server() const {
     return *test_server_;
   }
 
  protected:
   bool InitSafeBrowsingService() {
     safe_browsing_service_ = g_browser_process->safe_browsing_service();
     return safe_browsing_service_ != NULL;
@@ skipping 313 matching lines @@
               safe_browsing_helper->FetchDBToVerify(test_server(), step));
     EXPECT_GT(safe_browsing_helper->response_data().size(), 0U);
     last_step = step;
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(test_server(), last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
 }