1 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
6 
7 #include "base/strings/string_util.h"
8 #include "chrome/browser/safe_browsing/download_protection/download_protection_service.h"
9 #include "chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h"
10 #include "chrome/browser/safe_browsing/services_delegate.h"
11 #include "chrome/browser/safe_browsing/ui_manager.h"
12 #include "components/safe_browsing/buildflags.h"
13 #include "components/safe_browsing/core/db/database_manager.h"
14 #include "components/safe_browsing/core/db/test_database_manager.h"
15 
16 namespace safe_browsing {
17 
18 // TestSafeBrowsingService functions:
TestSafeBrowsingService()19 TestSafeBrowsingService::TestSafeBrowsingService()
20     : test_shared_loader_factory_(
21           base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
22               &test_url_loader_factory_)) {
23 #if BUILDFLAG(FULL_SAFE_BROWSING)
24   services_delegate_ = ServicesDelegate::CreateForTest(this, this);
25 #endif  // BUILDFLAG(FULL_SAFE_BROWSING)
26 }
27 
~TestSafeBrowsingService()28 TestSafeBrowsingService::~TestSafeBrowsingService() {}
29 
GetV4ProtocolConfig() const30 V4ProtocolConfig TestSafeBrowsingService::GetV4ProtocolConfig() const {
31   if (v4_protocol_config_)
32     return *v4_protocol_config_;
33   return SafeBrowsingService::GetV4ProtocolConfig();
34 }
35 
UseV4LocalDatabaseManager()36 void TestSafeBrowsingService::UseV4LocalDatabaseManager() {
37   use_v4_local_db_manager_ = true;
38 }
39 
SetUseTestUrlLoaderFactory(bool use_test_url_loader_factory)40 void TestSafeBrowsingService::SetUseTestUrlLoaderFactory(
41     bool use_test_url_loader_factory) {
42   use_test_url_loader_factory_ = use_test_url_loader_factory;
43 }
44 
45 network::TestURLLoaderFactory*
GetTestUrlLoaderFactory()46 TestSafeBrowsingService::GetTestUrlLoaderFactory() {
47   DCHECK(use_test_url_loader_factory_);
48   return &test_url_loader_factory_;
49 }
50 
51 std::unique_ptr<SafeBrowsingService::StateSubscription>
RegisterStateCallback(const base::RepeatingClosure & callback)52 TestSafeBrowsingService::RegisterStateCallback(
53     const base::RepeatingClosure& callback) {
54   // This override is required since TestSafeBrowsingService can be destroyed
55   // before CertificateReportingService, which causes a crash due to the
56   // leftover callback at destruction time.
57   return nullptr;
58 }
59 
serilized_download_report()60 std::string TestSafeBrowsingService::serilized_download_report() {
61   return serialized_download_report_;
62 }
63 
ClearDownloadReport()64 void TestSafeBrowsingService::ClearDownloadReport() {
65   serialized_download_report_.clear();
66 }
67 
SetDatabaseManager(TestSafeBrowsingDatabaseManager * database_manager)68 void TestSafeBrowsingService::SetDatabaseManager(
69     TestSafeBrowsingDatabaseManager* database_manager) {
70   SetDatabaseManagerForTest(database_manager);
71 }
72 
SetUIManager(TestSafeBrowsingUIManager * ui_manager)73 void TestSafeBrowsingService::SetUIManager(
74     TestSafeBrowsingUIManager* ui_manager) {
75   ui_manager->SetSafeBrowsingService(this);
76   ui_manager_ = ui_manager;
77 }
78 
CreateUIManager()79 SafeBrowsingUIManager* TestSafeBrowsingService::CreateUIManager() {
80   if (ui_manager_)
81     return ui_manager_.get();
82   return SafeBrowsingService::CreateUIManager();
83 }
84 
SendSerializedDownloadReport(Profile * profile,const std::string & report)85 void TestSafeBrowsingService::SendSerializedDownloadReport(
86     Profile* profile,
87     const std::string& report) {
88   serialized_download_report_ = report;
89 }
90 
91 const scoped_refptr<SafeBrowsingDatabaseManager>&
database_manager() const92 TestSafeBrowsingService::database_manager() const {
93   if (test_database_manager_)
94     return test_database_manager_;
95   return SafeBrowsingService::database_manager();
96 }
97 
SetV4ProtocolConfig(V4ProtocolConfig * v4_protocol_config)98 void TestSafeBrowsingService::SetV4ProtocolConfig(
99     V4ProtocolConfig* v4_protocol_config) {
100   v4_protocol_config_.reset(v4_protocol_config);
101 }
102 // ServicesDelegate::ServicesCreator:
CanCreateDatabaseManager()103 bool TestSafeBrowsingService::CanCreateDatabaseManager() {
104   return !use_v4_local_db_manager_;
105 }
106 #if BUILDFLAG(FULL_SAFE_BROWSING)
CanCreateDownloadProtectionService()107 bool TestSafeBrowsingService::CanCreateDownloadProtectionService() {
108   return false;
109 }
110 #endif
CanCreateIncidentReportingService()111 bool TestSafeBrowsingService::CanCreateIncidentReportingService() {
112   return true;
113 }
CanCreateResourceRequestDetector()114 bool TestSafeBrowsingService::CanCreateResourceRequestDetector() {
115   return false;
116 }
117 
CreateDatabaseManager()118 SafeBrowsingDatabaseManager* TestSafeBrowsingService::CreateDatabaseManager() {
119   DCHECK(!use_v4_local_db_manager_);
120 #if BUILDFLAG(FULL_SAFE_BROWSING)
121   return new TestSafeBrowsingDatabaseManager();
122 #else
123   NOTIMPLEMENTED();
124   return nullptr;
125 #endif  // BUILDFLAG(FULL_SAFE_BROWSING)
126 }
127 
128 #if BUILDFLAG(FULL_SAFE_BROWSING)
129 DownloadProtectionService*
CreateDownloadProtectionService()130 TestSafeBrowsingService::CreateDownloadProtectionService() {
131   NOTIMPLEMENTED();
132   return nullptr;
133 }
134 #endif
135 IncidentReportingService*
CreateIncidentReportingService()136 TestSafeBrowsingService::CreateIncidentReportingService() {
137 #if BUILDFLAG(FULL_SAFE_BROWSING)
138   return new IncidentReportingService(nullptr);
139 #else
140   NOTIMPLEMENTED();
141   return nullptr;
142 #endif  // BUILDFLAG(FULL_SAFE_BROWSING)
143 }
144 ResourceRequestDetector*
CreateResourceRequestDetector()145 TestSafeBrowsingService::CreateResourceRequestDetector() {
146   NOTIMPLEMENTED();
147   return nullptr;
148 }
149 
150 scoped_refptr<network::SharedURLLoaderFactory>
GetURLLoaderFactory()151 TestSafeBrowsingService::GetURLLoaderFactory() {
152   if (use_test_url_loader_factory_)
153     return test_shared_loader_factory_;
154   return SafeBrowsingService::GetURLLoaderFactory();
155 }
156 
157 scoped_refptr<network::SharedURLLoaderFactory>
GetURLLoaderFactory(Profile * profile)158 TestSafeBrowsingService::GetURLLoaderFactory(Profile* profile) {
159   if (use_test_url_loader_factory_)
160     return test_shared_loader_factory_;
161   return SafeBrowsingService::GetURLLoaderFactory(profile);
162 }
163 
164 // TestSafeBrowsingServiceFactory functions:
TestSafeBrowsingServiceFactory()165 TestSafeBrowsingServiceFactory::TestSafeBrowsingServiceFactory()
166     : test_safe_browsing_service_(nullptr), use_v4_local_db_manager_(false) {}
167 
~TestSafeBrowsingServiceFactory()168 TestSafeBrowsingServiceFactory::~TestSafeBrowsingServiceFactory() {}
169 
170 SafeBrowsingService*
CreateSafeBrowsingService()171 TestSafeBrowsingServiceFactory::CreateSafeBrowsingService() {
172   // Instantiate TestSafeBrowsingService.
173   test_safe_browsing_service_ = new TestSafeBrowsingService();
174   // Plug-in test member clases accordingly.
175   if (use_v4_local_db_manager_)
176     test_safe_browsing_service_->UseV4LocalDatabaseManager();
177   if (test_ui_manager_)
178     test_safe_browsing_service_->SetUIManager(test_ui_manager_.get());
179   if (test_database_manager_) {
180     test_safe_browsing_service_->SetDatabaseManager(
181         test_database_manager_.get());
182   }
183   return test_safe_browsing_service_;
184 }
185 
186 TestSafeBrowsingService*
test_safe_browsing_service()187 TestSafeBrowsingServiceFactory::test_safe_browsing_service() {
188   return test_safe_browsing_service_;
189 }
190 
SetTestUIManager(TestSafeBrowsingUIManager * ui_manager)191 void TestSafeBrowsingServiceFactory::SetTestUIManager(
192     TestSafeBrowsingUIManager* ui_manager) {
193   test_ui_manager_ = ui_manager;
194 }
195 
SetTestDatabaseManager(TestSafeBrowsingDatabaseManager * database_manager)196 void TestSafeBrowsingServiceFactory::SetTestDatabaseManager(
197     TestSafeBrowsingDatabaseManager* database_manager) {
198   test_database_manager_ = database_manager;
199 }
UseV4LocalDatabaseManager()200 void TestSafeBrowsingServiceFactory::UseV4LocalDatabaseManager() {
201   use_v4_local_db_manager_ = true;
202 }
203 
204 // TestSafeBrowsingUIManager functions:
TestSafeBrowsingUIManager()205 TestSafeBrowsingUIManager::TestSafeBrowsingUIManager()
206     : SafeBrowsingUIManager(nullptr) {}
207 
TestSafeBrowsingUIManager(const scoped_refptr<SafeBrowsingService> & service)208 TestSafeBrowsingUIManager::TestSafeBrowsingUIManager(
209     const scoped_refptr<SafeBrowsingService>& service)
210     : SafeBrowsingUIManager(service) {}
211 
SetSafeBrowsingService(SafeBrowsingService * sb_service)212 void TestSafeBrowsingUIManager::SetSafeBrowsingService(
213     SafeBrowsingService* sb_service) {
214   sb_service_ = sb_service;
215 }
216 
SendSerializedThreatDetails(content::BrowserContext * browser_context,const std::string & serialized)217 void TestSafeBrowsingUIManager::SendSerializedThreatDetails(
218     content::BrowserContext* browser_context,
219     const std::string& serialized) {
220   details_.push_back(serialized);
221 }
222 
GetThreatDetails()223 std::list<std::string>* TestSafeBrowsingUIManager::GetThreatDetails() {
224   return &details_;
225 }
226 
~TestSafeBrowsingUIManager()227 TestSafeBrowsingUIManager::~TestSafeBrowsingUIManager() {}
228 }  // namespace safe_browsing
229