Create test fixture for SafeBrowsingService

chrome/browser/safe_browsing/test_safe_browsing_service.h

Index: chrome/browser/safe_browsing/test_safe_browsing_service.h
diff --git a/chrome/browser/safe_browsing/test_safe_browsing_service.h b/chrome/browser/safe_browsing/test_safe_browsing_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..f2e377dd2fc4ca955d8ed5969114238c1c82cfd6
--- /dev/null
+++ b/chrome/browser/safe_browsing/test_safe_browsing_service.h
@@ -0,0 +1,131 @@
+// Copyright (c) 2016 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.
+
+#ifndef CHROME_BROWSER_SAFE_BROWSING_TEST_SAFE_BROWSING_SERVICE_H_
+#define CHROME_BROWSER_SAFE_BROWSING_TEST_SAFE_BROWSING_SERVICE_H_
+
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+
+#include "chrome/browser/safe_browsing/protocol_manager.h"
+#include "chrome/browser/safe_browsing/protocol_manager_helper.h"
+#include "chrome/browser/safe_browsing/ui_manager.h"
+#include "components/safe_browsing_db/v4_protocol_manager_util.h"
+
+namespace safe_browsing {
+struct SafeBrowsingProtocolConfig;
+class SafeBrowsingDatabaseManager;
+class SafeBrowsingPingManager;
+class SafeBrowsingProtocolManager;
+struct V4ProtocolConfig;
+class TestSafeBrowsingDatabaseManager;
+class TestSafeBrowsingUIManager;
+
+// TestSafeBrowsingService and its factory provides a flexible way to configure
+// customized safe browsing UI manager, database manager, protocol manager,
+// and etc without the need of override SafeBrowsingService in tests over and
+// over again.
+//
+// How to configure TestSafeBrowsingService in browser tests set up?
+// * When overriding SetUp():
+//   (1) create an instance of TestSafeBrowsingServiceFactory (
+//       e.g. test_sb_factory_),
+//   (2) Set up necessary test components by calling
+//       test_sb_factory_->SetTest[DatabaseManager/UIManager/...](...),
+//   (3) Register TestSafeBrowsingServiceFactory
+//       SafeBrowsingService::RegisterFactory(test_sb_factory_);
+//   (4) InProcessBrowserTest::SetUp() or other base class SetUp() function must
+//       be called at last.
+// * When overriding TearDown():
+//   Call base class TearDown() first then call
+//   SafeBrowsingService::RegisterFactory(nullptr) to unregister
+//   test_sb_factory_.
+class TestSafeBrowsingService : public SafeBrowsingService {
+ public:
+  TestSafeBrowsingService();
+  // SafeBrowsingService overrides
+  SafeBrowsingProtocolConfig GetProtocolConfig() const override;
+  V4ProtocolConfig GetV4ProtocolConfig() const override;
+
+  std::string serilized_download_report();
+  void ClearDownloadReport();
+
+  // In browser tests, the following setters must be called before
+  // SafeBrowsingService::Initialize().
+  // The preferable way to use these setters is by calling corresponding
+  // TestSafeBrowsingServiceFactory::SetTest[DatabaseManager/UIManager/
+  // ProtocolConfig]() before InProcessBrowserTest::SetUp() is called. Then
+  // inside TestSafeBrowsingServiceFactory::CreateSafeBrowsingService(),
+  // TestSafeBrowsingService instance is created, customised(by using the
+  // following setters), and then initialized.
+  void SetUIManager(TestSafeBrowsingUIManager* ui_manager);
+  void SetDatabaseManager(TestSafeBrowsingDatabaseManager* database_manager);
+  void SetProtocolConfig(SafeBrowsingProtocolConfig* protocol_config);
+  void SetV4ProtocolConfig(V4ProtocolConfig* v4_protocol_config);

[asanka, 2016/05/18 17:08:47]

At the moment we have two sets of SB satellite services. One set mediated by
ServicesDelegate, and allowing test overrides via ServiceCreator. Another set is
managed here. Shall we try to consolidate these?

[Jialiu Lin, 2016/05/18 19:06:55]

I tried to consolidate these two cases, but found it overly complicate the code.
I plan to leave download_browsertest, and download_protection_unittests (and
later the PPAPI download test once your CL is landed) to implement
ServicesDelegate. If I see more and more tests using the serviceDelegate, i will
add another test fixture for them. 

+
+ protected:
+  // SafeBrowsingService overrides
+  ~TestSafeBrowsingService() override;
+  SafeBrowsingDatabaseManager* CreateDatabaseManager() override;
+  SafeBrowsingUIManager* CreateUIManager() override;
+  SafeBrowsingProtocolManagerDelegate* GetProtocolManagerDelegate() override;
+  void SendSerializedDownloadReport(const std::string& report) override;
+
+ private:
+  bool protocol_manager_delegate_disabled_;
+  std::unique_ptr<SafeBrowsingProtocolConfig> protocol_config_;
+  std::unique_ptr<V4ProtocolConfig> v4_protocol_config_;
+  std::string serialized_download_report_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSafeBrowsingService);
+};
+
+class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
+ public:
+  TestSafeBrowsingServiceFactory();
+  ~TestSafeBrowsingServiceFactory() override;
+
+  // Creates test safe browsing service, and configures test UI manager,
+  // database manager and so on.
+  SafeBrowsingService* CreateSafeBrowsingService() override;
+
+  TestSafeBrowsingService* test_safe_browsing_service();
+
+  // Test UI manager, database manager and protocol config need to be set before
+  // SafeBrowsingService::Initialize() is called.
+  void SetTestUIManager(TestSafeBrowsingUIManager* ui_manager);
+  void SetTestDatabaseManager(
+      TestSafeBrowsingDatabaseManager* database_manager);
+  void SetTestProtocolConfig(const SafeBrowsingProtocolConfig& protocol_config);
+
+ private:
+  TestSafeBrowsingService* test_safe_browsing_service_;
+  scoped_refptr<TestSafeBrowsingDatabaseManager> test_database_manager_;
+  scoped_refptr<TestSafeBrowsingUIManager> test_ui_manager_;
+  SafeBrowsingProtocolConfig* test_protocol_config_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSafeBrowsingServiceFactory);
+};
+
+// This is an implemenation of SafeBrowsingUIManager without actually
+// sending report to safe browsing backend. Safe browsing reports are
+// stored in strings for easy verification.
+class TestSafeBrowsingUIManager : public SafeBrowsingUIManager {
+ public:
+  TestSafeBrowsingUIManager();
+  explicit TestSafeBrowsingUIManager(
+      const scoped_refptr<SafeBrowsingService>& service);
+  void SendSerializedThreatDetails(const std::string& serialized) override;
+  void SetSafeBrowsingService(SafeBrowsingService* sb_service);
+  std::list<std::string>* GetThreatDetails();
+
+ protected:
+  ~TestSafeBrowsingUIManager() override;
+  std::list<std::string> details_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSafeBrowsingUIManager);
+};
+
+}  // namespace safe_browsing
+
+#endif  // CHROME_BROWSER_SAFE_BROWSING_TEST_SAFE_BROWSING_SERVICE_H_