Create test fixture for SafeBrowsingService

chrome/browser/safe_browsing/safe_browsing_blocking_page_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 creates a fake safebrowsing service, where we can inject known-
 // threat urls.  It then uses a real browser to go to these urls, and sends
 // "goback" or "proceed" commands and verifies they work.
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/interstitials/security_interstitial_page_test_utils.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
-#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/threat_details.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
@@ skipping 93 matching lines @@
   }
 
  private:
   ~FakeSafeBrowsingDatabaseManager() override {}
 
   base::hash_map<std::string, SBThreatType> badurls;
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
 };
 
 // A SafeBrowingUIManager class that allows intercepting malware details.
-class FakeSafeBrowsingUIManager :  public SafeBrowsingUIManager {
+class FakeSafeBrowsingUIManager : public TestSafeBrowsingUIManager {
  public:
+  FakeSafeBrowsingUIManager()
+      : TestSafeBrowsingUIManager(), threat_details_done_(false) {}
   explicit FakeSafeBrowsingUIManager(SafeBrowsingService* service)
-      : SafeBrowsingUIManager(service), threat_details_done_(false) {}
+      : TestSafeBrowsingUIManager(service), threat_details_done_(false) {}
 
   // Overrides SafeBrowsingUIManager
   void SendSerializedThreatDetails(const std::string& serialized) override {
     // Notify the UI thread that we got a report.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&FakeSafeBrowsingUIManager::OnThreatDetailsDone, this,
                    serialized));
   }
 
@@ skipping 27 matching lines @@
   ~FakeSafeBrowsingUIManager() override {}
 
  private:
   std::string report_;
   base::Closure threat_details_done_callback_;
   bool threat_details_done_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingUIManager);
 };
 
-class FakeSafeBrowsingService : public SafeBrowsingService {
- public:
-  FakeSafeBrowsingService()
-      : fake_database_manager_(),
-        fake_ui_manager_() { }
-
-  // Returned pointer has the same lifespan as the database_manager_ refcounted
-  // object.
-  FakeSafeBrowsingDatabaseManager* fake_database_manager() {
-    return fake_database_manager_;
-  }
-  // Returned pointer has the same lifespan as the ui_manager_ refcounted
-  // object.
-  FakeSafeBrowsingUIManager* fake_ui_manager() {
-    return fake_ui_manager_;
-  }
-
- protected:
-  ~FakeSafeBrowsingService() override {}
-
-  SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
-    fake_database_manager_ = new FakeSafeBrowsingDatabaseManager();
-    return fake_database_manager_;
-  }
-
-  SafeBrowsingUIManager* CreateUIManager() override {
-    fake_ui_manager_ = new FakeSafeBrowsingUIManager(this);
-    return fake_ui_manager_;
-  }
-
-  SafeBrowsingProtocolManagerDelegate* GetProtocolManagerDelegate() override {
-    // Our SafeBrowsingDatabaseManager doesn't implement this delegate.
-    return NULL;
-  }
-
- private:
-  FakeSafeBrowsingDatabaseManager* fake_database_manager_;
-  FakeSafeBrowsingUIManager* fake_ui_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
-};
-
-// Factory that creates FakeSafeBrowsingService instances.
-class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
- public:
-  TestSafeBrowsingServiceFactory() :
-      most_recent_service_(NULL) { }
-  ~TestSafeBrowsingServiceFactory() override {}
-
-  SafeBrowsingService* CreateSafeBrowsingService() override {
-    most_recent_service_ =  new FakeSafeBrowsingService();
-    return most_recent_service_;
-  }
-
-  FakeSafeBrowsingService* most_recent_service() const {
-    return most_recent_service_;
-  }
-
- private:
-  FakeSafeBrowsingService* most_recent_service_;
-};
-
 }  // namespace
 
 class TestThreatDetailsFactory : public ThreatDetailsFactory {
  public:
   TestThreatDetailsFactory() : details_() {}
   ~TestThreatDetailsFactory() override {}
 
   ThreatDetails* CreateThreatDetails(
       SafeBrowsingUIManager* delegate,
       WebContents* web_contents,
@@ skipping 73 matching lines @@
  public:
   enum Visibility {
     VISIBILITY_ERROR = -1,
     HIDDEN = 0,
     VISIBLE = 1
   };
 
   SafeBrowsingBlockingPageBrowserTest() {}
 
   void SetUp() override {
+    // Test UI manager and test database manager should be set before
+    // InProcessBrowserTest::SetUp().
+    factory_.SetTestUIManager(new FakeSafeBrowsingUIManager());
+    factory_.SetTestDatabaseManager(new FakeSafeBrowsingDatabaseManager());
     SafeBrowsingService::RegisterFactory(&factory_);
     SafeBrowsingBlockingPage::RegisterFactory(&blocking_page_factory_);
     ThreatDetails::RegisterFactory(&details_factory_);
     InProcessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     InProcessBrowserTest::TearDown();
     SafeBrowsingBlockingPage::RegisterFactory(NULL);
     SafeBrowsingService::RegisterFactory(NULL);
     ThreatDetails::RegisterFactory(NULL);
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     if (testing::get<1>(GetParam()))
       content::IsolateAllSitesForTesting(command_line);
   }
 
   void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
   void SetURLThreatType(const GURL& url, SBThreatType threat_type) {
-    FakeSafeBrowsingService* service =
-        static_cast<FakeSafeBrowsingService*>(
-            g_browser_process->safe_browsing_service());
+    TestSafeBrowsingService* service = factory_.test_safe_browsing_service();
+    ASSERT_TRUE(service);
 
-    ASSERT_TRUE(service);
-    service->fake_database_manager()->SetURLThreatType(url, threat_type);
+    static_cast<FakeSafeBrowsingDatabaseManager*>(
+        service->database_manager().get())
+        ->SetURLThreatType(url, threat_type);
   }
 
   // Adds a safebrowsing result of the current test threat to the fake
   // safebrowsing service, navigates to that page, and returns the url.
   GURL SetupWarningAndNavigate() {
     GURL url = net::URLRequestMockHTTPJob::GetMockUrl(kEmptyPage);
     SetURLThreatType(url, testing::get<0>(GetParam()));
 
     ui_test_utils::NavigateToURL(browser(), url);
     EXPECT_TRUE(WaitForReady());
@@ skipping 56 matching lines @@
 
   bool YesInterstitial() {
     WebContents* contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     InterstitialPage* interstitial_page = InterstitialPage::GetInterstitialPage(
         contents);
     return interstitial_page != NULL;
   }
 
   void SetReportSentCallback(const base::Closure& callback) {
-    factory_.most_recent_service()
-        ->fake_ui_manager()
+    static_cast<FakeSafeBrowsingUIManager*>(
+        factory_.test_safe_browsing_service()->ui_manager().get())
         ->set_threat_details_done_callback(callback);
   }
 
   std::string GetReportSent() {
-    return factory_.most_recent_service()->fake_ui_manager()->GetReport();
+    return static_cast<FakeSafeBrowsingUIManager*>(
+               factory_.test_safe_browsing_service()->ui_manager().get())
+        ->GetReport();
   }
 
   void MalwareRedirectCancelAndProceed(const std::string& open_function) {
     GURL load_url = net::URLRequestMockHTTPJob::GetMockUrl(
         "safe_browsing/interstitial_cancel.html");
     GURL malware_url = net::URLRequestMockHTTPJob::GetMockUrl(kMalwarePage);
     SetURLThreatType(malware_url, testing::get<0>(GetParam()));
 
     // Load the test page.
     ui_test_utils::NavigateToURL(browser(), load_url);
@@ skipping 624 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     SafeBrowsingBlockingPageIDNTestWithThreatType,
     SafeBrowsingBlockingPageIDNTest,
     testing::Combine(testing::Values(false, true),
                      testing::Values(SB_THREAT_TYPE_URL_MALWARE,
                                      SB_THREAT_TYPE_URL_PHISHING,
                                      SB_THREAT_TYPE_URL_UNWANTED)));
 
 }  // namespace safe_browsing