Create test fixture for SafeBrowsingService

chrome/browser/safe_browsing/unverified_download_policy_unittest.cc

 // Copyright 2015 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 "chrome/browser/safe_browsing/unverified_download_policy.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/run_loop.h"
-#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace safe_browsing {
 
 namespace {
 
 class FakeDatabaseManager : public TestSafeBrowsingDatabaseManager {
  public:
   bool IsSupported() const override { return true; }
 
   bool MatchDownloadWhitelistUrl(const GURL& url) override {
     return url.SchemeIsHTTPOrHTTPS() && url.host() == "supported.example.com";
   }
 
  protected:
   ~FakeDatabaseManager() override {}
 };
 
-class TestSafeBrowsingService : public SafeBrowsingService {
- public:
-  SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
-    return new FakeDatabaseManager();
-  }
-
- protected:
-  ~TestSafeBrowsingService() override {}
-
-  SafeBrowsingProtocolManagerDelegate* GetProtocolManagerDelegate() override {
-    // Our FakeDatabaseManager doesn't implement this delegate.
-    return NULL;
-  }
-};
-
-class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
- public:
-  SafeBrowsingService* CreateSafeBrowsingService() override {
-    return new TestSafeBrowsingService();
-  }
-};
-
 class CompletionCallback {
  public:
   CompletionCallback() {}
 
   UnverifiedDownloadCheckCompletionCallback GetCallback() {
     completed_ = false;
     completion_closure_.Reset();
     return base::Bind(&CompletionCallback::OnUnverifiedDownloadPolicyAvailable,
                       base::Unretained(this));
   }
@@ skipping 16 matching lines @@
   }
 
   bool completed_ = false;
   base::Closure completion_closure_;
   UnverifiedDownloadPolicy result_ = UnverifiedDownloadPolicy::DISALLOWED;
 };
 
 class UnverifiedDownloadPolicyTest : public ::testing::Test {
  public:
   void SetUp() override {
-    SafeBrowsingService::RegisterFactory(&test_safe_browsing_service_factory_);
-    testing_safe_browsing_service_ =
-        SafeBrowsingService::CreateSafeBrowsingService();
+    SafeBrowsingService::RegisterFactory(
+        &testing_safe_browsing_service_factory_);
     TestingBrowserProcess* browser_process = TestingBrowserProcess::GetGlobal();
     browser_process->SetSafeBrowsingService(
-        testing_safe_browsing_service_.get());
+        testing_safe_browsing_service_factory_.CreateSafeBrowsingService());
     browser_process->safe_browsing_service()->Initialize();
+    // Set up FakeDatabaseManager.
+    testing_safe_browsing_service_factory_.test_safe_browsing_service()

[Nathan Parker, 2016/05/07 00:05:32]

Shouldn't this set the FakeDatabaseManager on the factory obj, and then let it
create/initialize it normally?

Also, do you need to register the factory if you're then invoking it directly?

[Jialiu Lin, 2016/05/12 21:53:58]

Ah, this is not a InProcessBrowserTest but rather a unit tests, and browser
process is already created. So we don't have to register the factory, but
calling browser_process->SetSafeBrowsingService() to force instantiate a
TestSafeBrowsingService instance. 
Though it is good idea to make it more consistent with other tests.

Used SetTestSafeBrowsingService() on factory obj instead. 

+        ->SetDatabaseManager(new FakeDatabaseManager());
     base::RunLoop().RunUntilIdle();
 
     testing_profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(testing_profile_manager_->SetUp());
 
     testing_profile_ = testing_profile_manager_->CreateTestingProfile("foo");
     testing_profile_->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled, true);
   }
 
   void TearDown() override {
     TestingBrowserProcess* browser_process = TestingBrowserProcess::GetGlobal();
     browser_process->safe_browsing_service()->ShutDown();
     browser_process->SetSafeBrowsingService(nullptr);

[Jialiu Lin, 2016/05/12 21:53:58]

No need this line, since TestSafeBrowsingFactory destructor takes care of it.

-    testing_safe_browsing_service_ = nullptr;
     SafeBrowsingService::RegisterFactory(nullptr);
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
-  TestSafeBrowsingServiceFactory test_safe_browsing_service_factory_;
+  TestSafeBrowsingServiceFactory testing_safe_browsing_service_factory_;
   std::unique_ptr<TestingProfileManager> testing_profile_manager_;
-  scoped_refptr<SafeBrowsingService> testing_safe_browsing_service_;
   TestingProfile* testing_profile_ = nullptr;
 };
 
 }  // namespace
 
 // Verify that SafeBrowsing whitelists can override field trials.
 TEST_F(UnverifiedDownloadPolicyTest, Whitelist) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kDisallowUncheckedDangerousDownloads);
 
@@ skipping 80 matching lines @@
 
   CompletionCallback completion_callback;
   CheckUnverifiedDownloadPolicy(GURL("http://supported.example.com/foo/bar"),
                                 test_file_path, test_extensions,
                                 completion_callback.GetCallback());
   EXPECT_EQ(UnverifiedDownloadPolicy::ALLOWED,
             completion_callback.WaitForResult());
 }
 
 }  // namespace safe_browsing