chrome/test/base/testing_browser_process.cc

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