1// Copyright (c) 2012 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/test/base/testing_browser_process.h"
6
7#include "base/prefs/pref_service.h"
8#include "base/strings/string_util.h"
9#include "base/time/default_tick_clock.h"
10#include "build/build_config.h"
11#include "chrome/browser/background/background_mode_manager.h"
12#include "chrome/browser/browser_process.h"
13#include "chrome/browser/browser_process_impl.h"
14#include "chrome/browser/printing/print_job_manager.h"
15#include "chrome/browser/profiles/profile_manager.h"
16#include "chrome/browser/ui/apps/chrome_app_window_client.h"
17#include "chrome/test/base/testing_browser_process_platform_part.h"
18#include "components/network_time/network_time_tracker.h"
19#include "content/public/browser/notification_service.h"
20#include "net/url_request/url_request_context_getter.h"
21#include "testing/gtest/include/gtest/gtest.h"
22#include "ui/message_center/message_center.h"
23
24#if !defined(OS_IOS)
25#include "chrome/browser/notifications/notification_ui_manager.h"
26#include "chrome/browser/prerender/prerender_tracker.h"
27#include "chrome/browser/safe_browsing/safe_browsing_service.h"
28#endif
29
30#if defined(ENABLE_CONFIGURATION_POLICY)
31#include "components/policy/core/browser/browser_policy_connector.h"
32#else
33#include "components/policy/core/common/policy_service_stub.h"
34#endif  // defined(ENABLE_CONFIGURATION_POLICY)
35
36#if defined(ENABLE_EXTENSIONS)
37#include "chrome/browser/extensions/chrome_extensions_browser_client.h"
38#include "chrome/browser/media_galleries/media_file_system_registry.h"
39#include "components/storage_monitor/storage_monitor.h"
40#include "components/storage_monitor/test_storage_monitor.h"
41#endif
42
43#if defined(ENABLE_FULL_PRINTING)
44#include "chrome/browser/printing/background_printing_manager.h"
45#include "chrome/browser/printing/print_preview_dialog_controller.h"
46#endif
47
48// static
49TestingBrowserProcess* TestingBrowserProcess::GetGlobal() {
50  return static_cast<TestingBrowserProcess*>(g_browser_process);
51}
52
53// static
54void TestingBrowserProcess::CreateInstance() {
55  DCHECK(!g_browser_process);
56  g_browser_process = new TestingBrowserProcess;
57}
58
59// static
60void TestingBrowserProcess::DeleteInstance() {
61  // g_browser_process must be NULL during its own destruction.
62  BrowserProcess* browser_process = g_browser_process;
63  g_browser_process = NULL;
64  delete browser_process;
65}
66
67TestingBrowserProcess::TestingBrowserProcess()
68    : notification_service_(content::NotificationService::Create()),
69      module_ref_count_(0),
70      app_locale_("en"),
71      local_state_(NULL),
72      io_thread_(NULL),
73      system_request_context_(NULL),
74      platform_part_(new TestingBrowserProcessPlatformPart()) {
75#if defined(ENABLE_EXTENSIONS)
76  extensions_browser_client_.reset(
77      new extensions::ChromeExtensionsBrowserClient);
78  extensions::AppWindowClient::Set(ChromeAppWindowClient::GetInstance());
79  extensions::ExtensionsBrowserClient::Set(extensions_browser_client_.get());
80#endif
81}
82
83TestingBrowserProcess::~TestingBrowserProcess() {
84  EXPECT_FALSE(local_state_);
85#if defined(ENABLE_CONFIGURATION_POLICY)
86  SetBrowserPolicyConnector(NULL);
87#endif
88#if defined(ENABLE_EXTENSIONS)
89  extensions::ExtensionsBrowserClient::Set(NULL);
90#endif
91
92  // Destructors for some objects owned by TestingBrowserProcess will use
93  // g_browser_process if it is not NULL, so it must be NULL before proceeding.
94  DCHECK_EQ(static_cast<BrowserProcess*>(NULL), g_browser_process);
95}
96
97void TestingBrowserProcess::ResourceDispatcherHostCreated() {
98}
99
100void TestingBrowserProcess::EndSession() {
101}
102
103MetricsServicesManager* TestingBrowserProcess::GetMetricsServicesManager() {
104  return NULL;
105}
106
107metrics::MetricsService* TestingBrowserProcess::metrics_service() {
108  return NULL;
109}
110
111rappor::RapporService* TestingBrowserProcess::rappor_service() {
112  return NULL;
113}
114
115IOThread* TestingBrowserProcess::io_thread() {
116  return io_thread_;
117}
118
119WatchDogThread* TestingBrowserProcess::watchdog_thread() {
120  return NULL;
121}
122
123ProfileManager* TestingBrowserProcess::profile_manager() {
124#if defined(OS_IOS)
125  NOTIMPLEMENTED();
126  return NULL;
127#else
128  return profile_manager_.get();
129#endif
130}
131
132void TestingBrowserProcess::SetProfileManager(ProfileManager* profile_manager) {
133#if !defined(OS_IOS)
134  // NotificationUIManager can contain references to elements in the current
135  // ProfileManager (for example, the MessageCenterSettingsController maintains
136  // a pointer to the ProfileInfoCache). So when we change the ProfileManager
137  // (typically during test shutdown) make sure to reset any objects that might
138  // maintain references to it. See SetLocalState() for a description of a
139  // similar situation.
140  notification_ui_manager_.reset();
141  profile_manager_.reset(profile_manager);
142#endif
143}
144
145PrefService* TestingBrowserProcess::local_state() {
146  return local_state_;
147}
148
149chrome_variations::VariationsService*
150    TestingBrowserProcess::variations_service() {
151  return NULL;
152}
153
154policy::BrowserPolicyConnector*
155    TestingBrowserProcess::browser_policy_connector() {
156#if defined(ENABLE_CONFIGURATION_POLICY)
157  if (!browser_policy_connector_)
158    browser_policy_connector_ = platform_part_->CreateBrowserPolicyConnector();
159  return browser_policy_connector_.get();
160#else
161  return NULL;
162#endif
163}
164
165policy::PolicyService* TestingBrowserProcess::policy_service() {
166#if defined(OS_IOS)
167  NOTIMPLEMENTED();
168  return NULL;
169#elif defined(ENABLE_CONFIGURATION_POLICY)
170  return browser_policy_connector()->GetPolicyService();
171#else
172  if (!policy_service_)
173    policy_service_.reset(new policy::PolicyServiceStub());
174  return policy_service_.get();
175#endif
176}
177
178IconManager* TestingBrowserProcess::icon_manager() {
179  return NULL;
180}
181
182GLStringManager* TestingBrowserProcess::gl_string_manager() {
183  return NULL;
184}
185
186GpuModeManager* TestingBrowserProcess::gpu_mode_manager() {
187  return NULL;
188}
189
190BackgroundModeManager* TestingBrowserProcess::background_mode_manager() {
191  return NULL;
192}
193
194void TestingBrowserProcess::set_background_mode_manager_for_test(
195    scoped_ptr<BackgroundModeManager> manager) {
196  NOTREACHED();
197}
198
199StatusTray* TestingBrowserProcess::status_tray() {
200  return NULL;
201}
202
203SafeBrowsingService* TestingBrowserProcess::safe_browsing_service() {
204#if defined(OS_IOS)
205  NOTIMPLEMENTED();
206  return NULL;
207#else
208  return sb_service_.get();
209#endif
210}
211
212safe_browsing::ClientSideDetectionService*
213TestingBrowserProcess::safe_browsing_detection_service() {
214  return NULL;
215}
216
217net::URLRequestContextGetter* TestingBrowserProcess::system_request_context() {
218  return system_request_context_;
219}
220
221BrowserProcessPlatformPart* TestingBrowserProcess::platform_part() {
222  return platform_part_.get();
223}
224
225extensions::EventRouterForwarder*
226TestingBrowserProcess::extension_event_router_forwarder() {
227  return NULL;
228}
229
230NotificationUIManager* TestingBrowserProcess::notification_ui_manager() {
231#if defined(ENABLE_NOTIFICATIONS)
232  if (!notification_ui_manager_.get())
233    notification_ui_manager_.reset(
234        NotificationUIManager::Create(local_state()));
235  return notification_ui_manager_.get();
236#else
237  NOTIMPLEMENTED();
238  return NULL;
239#endif
240}
241
242message_center::MessageCenter* TestingBrowserProcess::message_center() {
243  return message_center::MessageCenter::Get();
244}
245
246IntranetRedirectDetector* TestingBrowserProcess::intranet_redirect_detector() {
247  return NULL;
248}
249void TestingBrowserProcess::CreateDevToolsHttpProtocolHandler(
250    chrome::HostDesktopType host_desktop_type,
251    const std::string& ip,
252    int port) {
253}
254
255unsigned int TestingBrowserProcess::AddRefModule() {
256  return ++module_ref_count_;
257}
258
259unsigned int TestingBrowserProcess::ReleaseModule() {
260  DCHECK_GT(module_ref_count_, 0U);
261  return --module_ref_count_;
262}
263
264bool TestingBrowserProcess::IsShuttingDown() {
265  return false;
266}
267
268printing::PrintJobManager* TestingBrowserProcess::print_job_manager() {
269#if defined(ENABLE_PRINTING)
270  if (!print_job_manager_.get())
271    print_job_manager_.reset(new printing::PrintJobManager());
272  return print_job_manager_.get();
273#else
274  NOTIMPLEMENTED();
275  return NULL;
276#endif
277}
278
279printing::PrintPreviewDialogController*
280TestingBrowserProcess::print_preview_dialog_controller() {
281#if defined(ENABLE_FULL_PRINTING)
282  if (!print_preview_dialog_controller_.get())
283    print_preview_dialog_controller_ =
284        new printing::PrintPreviewDialogController();
285  return print_preview_dialog_controller_.get();
286#else
287  NOTIMPLEMENTED();
288  return NULL;
289#endif
290}
291
292printing::BackgroundPrintingManager*
293TestingBrowserProcess::background_printing_manager() {
294#if defined(ENABLE_FULL_PRINTING)
295  if (!background_printing_manager_.get()) {
296    background_printing_manager_.reset(
297        new printing::BackgroundPrintingManager());
298  }
299  return background_printing_manager_.get();
300#else
301  NOTIMPLEMENTED();
302  return NULL;
303#endif
304}
305
306const std::string& TestingBrowserProcess::GetApplicationLocale() {
307  return app_locale_;
308}
309
310void TestingBrowserProcess::SetApplicationLocale(
311    const std::string& app_locale) {
312  app_locale_ = app_locale;
313}
314
315DownloadStatusUpdater* TestingBrowserProcess::download_status_updater() {
316  return NULL;
317}
318
319DownloadRequestLimiter* TestingBrowserProcess::download_request_limiter() {
320  return NULL;
321}
322
323ChromeNetLog* TestingBrowserProcess::net_log() {
324  return NULL;
325}
326
327prerender::PrerenderTracker* TestingBrowserProcess::prerender_tracker() {
328#if defined(OS_IOS)
329  NOTIMPLEMENTED();
330  return NULL;
331#else
332  if (!prerender_tracker_.get())
333    prerender_tracker_.reset(new prerender::PrerenderTracker());
334  return prerender_tracker_.get();
335#endif
336}
337
338component_updater::ComponentUpdateService*
339TestingBrowserProcess::component_updater() {
340  return NULL;
341}
342
343CRLSetFetcher* TestingBrowserProcess::crl_set_fetcher() {
344  return NULL;
345}
346
347component_updater::PnaclComponentInstaller*
348TestingBrowserProcess::pnacl_component_installer() {
349  return NULL;
350}
351
352MediaFileSystemRegistry* TestingBrowserProcess::media_file_system_registry() {
353#if defined(OS_IOS) || defined(OS_ANDROID)
354  NOTIMPLEMENTED();
355  return NULL;
356#else
357  if (!media_file_system_registry_)
358    media_file_system_registry_.reset(new MediaFileSystemRegistry());
359  return media_file_system_registry_.get();
360#endif
361}
362
363bool TestingBrowserProcess::created_local_state() const {
364    return (local_state_ != NULL);
365}
366
367#if defined(ENABLE_WEBRTC)
368WebRtcLogUploader* TestingBrowserProcess::webrtc_log_uploader() {
369  return NULL;
370}
371#endif
372
373network_time::NetworkTimeTracker*
374TestingBrowserProcess::network_time_tracker() {
375  if (!network_time_tracker_) {
376    DCHECK(local_state_);
377    network_time_tracker_.reset(new network_time::NetworkTimeTracker(
378        scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
379        local_state_));
380  }
381  return network_time_tracker_.get();
382}
383
384gcm::GCMDriver* TestingBrowserProcess::gcm_driver() {
385  return NULL;
386}
387
388void TestingBrowserProcess::SetSystemRequestContext(
389    net::URLRequestContextGetter* context_getter) {
390  system_request_context_ = context_getter;
391}
392
393void TestingBrowserProcess::SetLocalState(PrefService* local_state) {
394  if (!local_state) {
395    // The local_state_ PrefService is owned outside of TestingBrowserProcess,
396    // but some of the members of TestingBrowserProcess hold references to it
397    // (for example, via PrefNotifier members). But given our test
398    // infrastructure which tears down individual tests before freeing the
399    // TestingBrowserProcess, there's not a good way to make local_state outlive
400    // these dependencies. As a workaround, whenever local_state_ is cleared
401    // (assumedly as part of exiting the test and freeing TestingBrowserProcess)
402    // any components owned by TestingBrowserProcess that depend on local_state
403    // are also freed.
404    network_time_tracker_.reset();
405#if !defined(OS_IOS)
406    notification_ui_manager_.reset();
407#endif
408#if defined(ENABLE_CONFIGURATION_POLICY)
409    SetBrowserPolicyConnector(NULL);
410#endif
411  }
412  local_state_ = local_state;
413}
414
415void TestingBrowserProcess::SetIOThread(IOThread* io_thread) {
416  io_thread_ = io_thread;
417}
418
419void TestingBrowserProcess::SetBrowserPolicyConnector(
420    policy::BrowserPolicyConnector* connector) {
421#if defined(ENABLE_CONFIGURATION_POLICY)
422  if (browser_policy_connector_) {
423    browser_policy_connector_->Shutdown();
424  }
425  browser_policy_connector_.reset(connector);
426#else
427  CHECK(false);
428#endif
429}
430
431void TestingBrowserProcess::SetSafeBrowsingService(
432    SafeBrowsingService* sb_service) {
433#if !defined(OS_IOS)
434  NOTIMPLEMENTED();
435  sb_service_ = sb_service;
436#endif
437}
438
439///////////////////////////////////////////////////////////////////////////////
440
441TestingBrowserProcessInitializer::TestingBrowserProcessInitializer() {
442  TestingBrowserProcess::CreateInstance();
443}
444
445TestingBrowserProcessInitializer::~TestingBrowserProcessInitializer() {
446  TestingBrowserProcess::DeleteInstance();
447}
448