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