Create test fixture for SafeBrowsingService

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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 safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 
@@ skipping 19 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
+#include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/bookmarks/browser/startup_task_runner_service.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/metadata.pb.h"
+#include "components/safe_browsing_db/test_database_manager.h"
 #include "components/safe_browsing_db/util.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/cookies/cookie_store.h"
 #include "net/cookies/cookie_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ skipping 50 matching lines @@
     return nullptr;
   return base::WrapUnique(new NeverCompletingHttpResponse());
 }
 
 void InvokeFullHashCallback(
     SafeBrowsingProtocolManager::FullHashCallback callback,
     const std::vector<SBFullHashResult>& result) {
   callback.Run(result, base::TimeDelta::FromMinutes(45));
 }
 
-class FakeSafeBrowsingUIManager : public SafeBrowsingUIManager {
+// Helper function to set up protocol config. It is used to redirects safe
+// browsing queries to embeded test server. It needs to be called before
+// SafeBrowsingService being created, therefore it is preferred to call this
+// function before InProcessBrowserTest::SetUp().
+void SetProtocolConfigURLPrefix(const std::string& url_prefix,
+                                TestSafeBrowsingServiceFactory* factory) {
+  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";
+  factory->SetTestProtocolConfig(config);
+}
+
+class FakeSafeBrowsingUIManager : public TestSafeBrowsingUIManager {
  public:
-  explicit FakeSafeBrowsingUIManager(SafeBrowsingService* service)
-      : SafeBrowsingUIManager(service) {}
-
   void MaybeReportSafeBrowsingHit(
       const safe_browsing::HitReport& hit_report) override {
     EXPECT_FALSE(got_hit_report_);
     got_hit_report_ = true;
     hit_report_ = hit_report;
     SafeBrowsingUIManager::MaybeReportSafeBrowsingHit(hit_report);
   }
 
   bool got_hit_report_ = false;
   safe_browsing::HitReport hit_report_;
 
  private:
   ~FakeSafeBrowsingUIManager() override {}
 };
 
-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;
-  }
-
- protected:
-  SafeBrowsingUIManager* CreateUIManager() override {
-    return new FakeSafeBrowsingUIManager(this);
-  }
-
- 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_;
-};
-
 // A SafeBrowingDatabase class that allows us to inject the malicious URLs.
 class TestSafeBrowsingDatabase : public SafeBrowsingDatabase {
  public:
   TestSafeBrowsingDatabase() {}
 
   ~TestSafeBrowsingDatabase() override {}
 
   // Initializes the database with the given filename.
   void Init(const base::FilePath& filename) override {}
 
@@ skipping 314 matching lines @@
                                    int list_id,
                                    SBFullHashResult* full_hash) {
     std::string host;
     std::string path;
     CanonicalizeUrl(url, &host, &path, NULL);
     full_hash->hash = SBFullHashForString(host + path);
     full_hash->list_id = list_id;
   }
 
   void SetUp() override {
-    // InProcessBrowserTest::SetUp() instantiates SafebrowsingService and
-    // RegisterFactory has to be called before SafeBrowsingService is created.
-    sb_factory_.reset(new TestSafeBrowsingServiceFactory(
-        "https://definatelynotarealdomain/safebrowsing"));
+    // InProcessBrowserTest::SetUp() instantiates SafebrowsingService.
+    // RegisterFactory and plugging test UI manager / protocol config have to
+    // be called before SafeBrowsingService is created.
+    sb_factory_.reset(new TestSafeBrowsingServiceFactory());
+    sb_factory_->SetTestUIManager(new FakeSafeBrowsingUIManager());
+    SetProtocolConfigURLPrefix("https://definatelynotarealdomain/safebrowsing",
+                               sb_factory_.get());
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
     SafeBrowsingDatabase::RegisterFactory(&db_factory_);
     SafeBrowsingProtocolManager::RegisterFactory(&pm_factory_);
     InProcessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     InProcessBrowserTest::TearDown();
 
     // Unregister test factories after InProcessBrowserTest::TearDown
@@ skipping 1039 matching lines @@
 class SafeBrowsingDatabaseManagerCookieTest : public InProcessBrowserTest {
  public:
   SafeBrowsingDatabaseManagerCookieTest() {}
 
   void SetUp() override {
     // We need to start the test server to get the host&port in the url.
     ASSERT_TRUE(embedded_test_server()->Start());
     embedded_test_server()->RegisterRequestHandler(
         base::Bind(&SafeBrowsingDatabaseManagerCookieTest::HandleRequest));
 
-    // Point to the testing server for all SafeBrowsing requests.
-    GURL url_prefix = embedded_test_server()->GetURL("/testpath");
-    sb_factory_.reset(new TestSafeBrowsingServiceFactory(url_prefix.spec()));
+    sb_factory_.reset(new TestSafeBrowsingServiceFactory());
+    SetProtocolConfigURLPrefix(
+        embedded_test_server()->GetURL("/testpath").spec(), sb_factory_.get());
     SafeBrowsingService::RegisterFactory(sb_factory_.get());
 
     InProcessBrowserTest::SetUp();
   }
 
   void TearDown() override {
     InProcessBrowserTest::TearDown();
 
     SafeBrowsingService::RegisterFactory(NULL);
   }
@@ skipping 33 matching lines @@
       return false;
     }
     if (!smt.BindString(0, embedded_test_server()->base_url().host())) {
       EXPECT_TRUE(false);
       return false;
     }
     if (!smt.Run()) {
       EXPECT_TRUE(false);
       return false;
     }
-
     return InProcessBrowserTest::SetUpUserDataDirectory();
   }
 
   void TearDownInProcessBrowserTestFixture() override {
     InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
 
     sql::Connection db;
     base::FilePath cookie_path(
         SafeBrowsingService::GetCookieFilePathForTesting());
     ASSERT_TRUE(db.Open(cookie_path));
 
     sql::Statement smt(
         db.GetUniqueStatement("SELECT name, value FROM cookies ORDER BY name"));
     ASSERT_TRUE(smt.is_valid());
-
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("a", smt.ColumnString(0));
     ASSERT_EQ("b", smt.ColumnString(1));
     ASSERT_TRUE(smt.Step());
     ASSERT_EQ("c", smt.ColumnString(0));
     ASSERT_EQ("d", smt.ColumnString(1));
     EXPECT_FALSE(smt.Step());
   }
 
-  void SetUpOnMainThread() override {
-    sb_service_ = g_browser_process->safe_browsing_service();
-    ASSERT_TRUE(sb_service_.get() != NULL);
+  void ForceUpdate() {
+    sb_factory_->test_safe_browsing_service()
+        ->protocol_manager()
+        ->ForceScheduleNextUpdate(base::TimeDelta::FromSeconds(0));
   }
 
-  void TearDownOnMainThread() override { sb_service_ = NULL; }
+  std::unique_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
 
-  void ForceUpdate() {
-    sb_service_->protocol_manager()->ForceScheduleNextUpdate(
-        base::TimeDelta::FromSeconds(0));
-  }
-
-  scoped_refptr<SafeBrowsingService> sb_service_;
-
- private:
+ protected:
   static std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request) {
     if (!base::StartsWith(request.relative_url, "/testpath/",
                           base::CompareCase::SENSITIVE)) {
       ADD_FAILURE() << "bad path";
       return nullptr;
     }
 
     auto cookie_it = request.headers.find("Cookie");
     if (cookie_it == request.headers.end()) {
@@ skipping 17 matching lines @@
 
     std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse());
     http_response->set_content("foo");
     http_response->set_content_type("text/plain");
     http_response->AddCustomHeader(
         "Set-Cookie", "c=d; Expires=Fri, 01 Jan 2038 01:01:01 GMT");
     return std::move(http_response);
   }
 
-  std::unique_ptr<TestSafeBrowsingServiceFactory> sb_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDatabaseManagerCookieTest);
 };
 
 // Test that a Local Safe Browsing database update request both sends cookies
 // and can save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingDatabaseManagerCookieTest,
                        TestSBUpdateCookies) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingDatabaseManager>(
-          sb_service_->database_manager().get()));
+          sb_factory_->test_safe_browsing_service()->database_manager().get()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingDatabaseManagerCookieTest::ForceUpdate, this));
   observer.Wait();
 }
 
 }  // namespace safe_browsing