Create test fixture for SafeBrowsingService

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 20 matching lines @@
 #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/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/safe_browsing/test_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 "components/safe_browsing_db/database_manager.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"
@@ skipping 56 matching lines @@
     } else {
       LOG(ERROR) << "Unrecognized expectation in " << url_str.as_string()
                  << ": " << record_parts[2];
       return false;
     }
     phishing_urls->push_back(phishing_url);
   }
   return true;
 }
 
-class FakeSafeBrowsingService : public SafeBrowsingService {
- public:
-  explicit FakeSafeBrowsingService(const std::string& url_prefix)
-      : url_prefix_(url_prefix) {}
-
-  SafeBrowsingProtocolConfig GetProtocolConfig() const override {
-    SafeBrowsingProtocolConfig config;
-    config.url_prefix = url_prefix_;
-    // Makes sure the auto update is not triggered. The tests will force the
-    // update when needed.
-    config.disable_auto_update = true;
-    config.client_name = "browser_tests";
-    return config;
-  }
-
- private:
-  ~FakeSafeBrowsingService() override {}
-
-  std::string url_prefix_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
-};
-
-// Factory that creates FakeSafeBrowsingService instances.
-class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
- public:
-  explicit TestSafeBrowsingServiceFactory(const std::string& url_prefix)
-      : url_prefix_(url_prefix) {}
-
-  SafeBrowsingService* CreateSafeBrowsingService() override {
-    return new FakeSafeBrowsingService(url_prefix_);
-  }
-
- private:
-  std::string url_prefix_;
-};
-
 }  // namespace
 
 // This starts the browser and keeps status of states related to SafeBrowsing.
 class SafeBrowsingServerTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServerTest()
-    : safe_browsing_service_(NULL),
-      is_database_ready_(true),
+    : is_database_ready_(true),
       is_update_scheduled_(false),
       is_checked_url_in_db_(false),
       is_checked_url_safe_(false) {
   }
 
   ~SafeBrowsingServerTest() override {}
 
   void UpdateSafeBrowsingStatus() {
-    ASSERT_TRUE(safe_browsing_service_);
+    ASSERT_TRUE(sb_factory_->test_safe_browsing_service());
     base::AutoLock lock(update_status_mutex_);
-    last_update_ = safe_browsing_service_->protocol_manager_->last_update();
+    last_update_ = sb_factory_->test_safe_browsing_service()
+        ->protocol_manager_->last_update();
     is_update_scheduled_ =
-        safe_browsing_service_->protocol_manager_->update_timer_.IsRunning();
+        sb_factory_->test_safe_browsing_service()->protocol_manager_
+        ->update_timer_.IsRunning();
   }
 
   void ForceUpdate() {
     content::WindowedNotificationObserver observer(
         chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
         content::Source<SafeBrowsingDatabaseManager>(database_manager()));
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&SafeBrowsingServerTest::ForceUpdateOnIOThread,
                    this));
     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));
+    ASSERT_TRUE(sb_factory_->test_safe_browsing_service());
+    sb_factory_->test_safe_browsing_service()->protocol_manager_
+        ->ForceScheduleNextUpdate(base::TimeDelta::FromSeconds(0));
   }
 
 
   void CheckIsDatabaseReady() {
     base::AutoLock lock(update_status_mutex_);
     is_database_ready_ =
         !local_database_manager()->database_update_in_progress_;
   }
 
   void CheckUrl(SafeBrowsingDatabaseManager::Client* helper, const GURL& url) {
-    ASSERT_TRUE(safe_browsing_service_);
+    ASSERT_TRUE(sb_factory_->test_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();
+    return sb_factory_->test_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() {
@@ skipping 28 matching lines @@
 
   scoped_refptr<base::SequencedTaskRunner> SafeBrowsingTaskRunner() {
     return local_database_manager()->safe_browsing_task_runner_;
   }
 
   const net::SpawnedTestServer& spawned_test_server() const {
     return *test_server_;
   }
 
  protected:
-  bool InitSafeBrowsingService() {
-    safe_browsing_service_ = g_browser_process->safe_browsing_service();
-    return safe_browsing_service_ != NULL;
+  void SetProtocolConfigURLPrefix(const std::string& url_prefix) {
+    SafeBrowsingProtocolConfig config;
+    config.url_prefix = url_prefix;
+    // Makes sure the auto update is not triggered. The tests will force the
+    // update when needed.
+    config.disable_auto_update = true;
+    config.client_name = "browser_tests";
+    sb_factory_->SetTestProtocolConfig(config);
   }
 
   void SetUp() override {
     base::FilePath datafile_path;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &datafile_path));
 
     datafile_path = datafile_path.Append(FILE_PATH_LITERAL("third_party"))
           .Append(FILE_PATH_LITERAL("safe_browsing"))
           .Append(FILE_PATH_LITERAL("testing"))
           .Append(kDataFile);
     test_server_.reset(new LocalSafeBrowsingTestServer(datafile_path));
     ASSERT_TRUE(test_server_->Start());
     LOG(INFO) << "server is " << test_server_->host_port_pair().ToString();
 
+    sb_factory_.reset(new TestSafeBrowsingServiceFactory());
     // Point to the testing server for all SafeBrowsing requests.
-    std::string url_prefix = test_server_->GetURL("safebrowsing").spec();
-    sb_factory_.reset(new TestSafeBrowsingServiceFactory(url_prefix));
+    SetProtocolConfigURLPrefix(test_server_->GetURL("safebrowsing").spec());
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
 
     InProcessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     InProcessBrowserTest::TearDown();
 
     SafeBrowsingService::RegisterFactory(NULL);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     // TODO(lzheng): The test server does not understand download related
     // requests. We need to fix the server.
     command_line->AppendSwitch(switches::kSbDisableDownloadProtection);
 
     // TODO(gcasto): Generate new testing data that includes the
     // client-side phishing whitelist.
     command_line->AppendSwitch(
         switches::kDisableClientSidePhishingDetection);
 
     // TODO(kalman): Generate new testing data that includes the extension
     // blacklist.
     command_line->AppendSwitch(switches::kSbDisableExtensionBlacklist);
   }
 
   void SetTestStep(int step) {
     std::string test_step = base::StringPrintf("test_step=%d", step);
-    safe_browsing_service_->protocol_manager_->set_additional_query(test_step);
+    sb_factory_->test_safe_browsing_service()->protocol_manager_
+        ->set_additional_query(test_step);
   }
 
- private:
   std::unique_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
 
-  SafeBrowsingService* safe_browsing_service_;
-
+ private:
   std::unique_ptr<net::SpawnedTestServer> test_server_;
 
   // Protects all variables below since they are read on UI thread
   // but updated on IO thread or safebrowsing thread.
   base::Lock update_status_mutex_;
 
   // States associated with safebrowsing service updates.
   bool is_database_ready_;
   base::Time last_update_;
   bool is_update_scheduled_;
@@ skipping 162 matching lines @@
   std::unique_ptr<net::URLFetcher> url_fetcher_;
   std::string response_data_;
   net::URLRequestStatus::Status response_status_;
   net::URLRequestContextGetter* request_context_;
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServerTestHelper);
 };
 
 // TODO(shess): Disabled pending new data for third_party/safe_browsing/testing/
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServerTest,
                        DISABLED_SafeBrowsingServerTest) {
-  LOG(INFO) << "Start test";
-  ASSERT_TRUE(InitSafeBrowsingService());
+  ASSERT_TRUE(sb_factory_->test_safe_browsing_service() != NULL);
 
   net::URLRequestContextGetter* request_context =
       browser()->profile()->GetRequestContext();
   scoped_refptr<SafeBrowsingServerTestHelper> safe_browsing_helper(
       new SafeBrowsingServerTestHelper(this, request_context));
   int last_step = 0;
 
   // Waits and makes sure safebrowsing update is not happening.
   // The wait will stop once OnWaitForStatusUpdateDone in
-  // safe_browsing_helper is called and status from safe_browsing_service_
+  // safe_browsing_helper is called and status from test_safe_browsing_service
   // is checked.
   safe_browsing_helper->UpdateStatus();
   EXPECT_TRUE(is_database_ready());
   EXPECT_FALSE(is_update_scheduled());
   EXPECT_TRUE(last_update().is_null());
   // Starts updates. After each update, the test will fetch a list of URLs with
   // expected results to verify with safebrowsing service. If there is no error,
   // the test moves on to the next step to get more update chunks.
   // This repeats till there is no update data.
   for (int step = 1;; step++) {
@@ skipping 56 matching lines @@
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(spawned_test_server(),
                                                      last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
 }
 
 }  // namespace safe_browsing