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   ShutdownBrowserPolicyConnector();
  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 variations::VariationsService* TestingBrowserProcess::variations_service() {
 152   return nullptr;
 153 }
 154
 155 web_resource::PromoResourceService*
 156 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     EXPECT_FALSE(created_browser_policy_connector_);
 165     created_browser_policy_connector_ = true;
 166     browser_policy_connector_ = platform_part_->CreateBrowserPolicyConnector();
 167   }
 168   return browser_policy_connector_.get();
 169 #else
 170   return nullptr;
 171 #endif
 172 }
 173
 174 policy::PolicyService* TestingBrowserProcess::policy_service() {
 175 #if defined(OS_IOS)
 176   NOTIMPLEMENTED();
 177   return nullptr;
 178 #elif defined(ENABLE_CONFIGURATION_POLICY)
 179   return browser_policy_connector()->GetPolicyService();
 180 #else
 181   if (!policy_service_)
 182     policy_service_.reset(new policy::PolicyServiceStub());
 183   return policy_service_.get();
 184 #endif
 185 }
 186
 187 IconManager* TestingBrowserProcess::icon_manager() {
 188   return nullptr;
 189 }
 190
 191 GLStringManager* TestingBrowserProcess::gl_string_manager() {
 192   return nullptr;
 193 }
 194
 195 GpuModeManager* TestingBrowserProcess::gpu_mode_manager() {
 196   return nullptr;
 197 }
 198
 199 BackgroundModeManager* TestingBrowserProcess::background_mode_manager() {
 200   return nullptr;
 201 }
 202
 203 void TestingBrowserProcess::set_background_mode_manager_for_test(
 204     scoped_ptr<BackgroundModeManager> manager) {
 205   NOTREACHED();
 206 }
 207
 208 StatusTray* TestingBrowserProcess::status_tray() {
 209   return nullptr;
 210 }
 211
 212 SafeBrowsingService* TestingBrowserProcess::safe_browsing_service() {
 213 #if defined(OS_IOS)
 214   NOTIMPLEMENTED();
 215   return nullptr;
 216 #else
 217   return sb_service_.get();
 218 #endif
 219 }
 220
 221 safe_browsing::ClientSideDetectionService*
 222 TestingBrowserProcess::safe_browsing_detection_service() {
 223   return nullptr;
 224 }
 225
 226 net::URLRequestContextGetter* TestingBrowserProcess::system_request_context() {
 227   return system_request_context_;
 228 }
 229
 230 BrowserProcessPlatformPart* TestingBrowserProcess::platform_part() {
 231   return platform_part_.get();
 232 }
 233
 234 extensions::EventRouterForwarder*
 235 TestingBrowserProcess::extension_event_router_forwarder() {
 236   return nullptr;
 237 }
 238
 239 NotificationUIManager* TestingBrowserProcess::notification_ui_manager() {
 240 #if defined(ENABLE_NOTIFICATIONS)
 241   if (!notification_ui_manager_.get())
 242     notification_ui_manager_.reset(
 243         NotificationUIManager::Create(local_state()));
 244   return notification_ui_manager_.get();
 245 #else
 246   NOTIMPLEMENTED();
 247   return nullptr;
 248 #endif
 249 }
 250
 251 message_center::MessageCenter* TestingBrowserProcess::message_center() {
 252   return message_center::MessageCenter::Get();
 253 }
 254
 255 IntranetRedirectDetector* TestingBrowserProcess::intranet_redirect_detector() {
 256   return nullptr;
 257 }
 258 void TestingBrowserProcess::CreateDevToolsHttpProtocolHandler(
 259     chrome::HostDesktopType host_desktop_type,
 260     const std::string& ip,
 261     uint16 port) {
 262 }
 263
 264 unsigned int TestingBrowserProcess::AddRefModule() {
 265   return ++module_ref_count_;
 266 }
 267
 268 unsigned int TestingBrowserProcess::ReleaseModule() {
 269   DCHECK_GT(module_ref_count_, 0U);
 270   return --module_ref_count_;
 271 }
 272
 273 bool TestingBrowserProcess::IsShuttingDown() {
 274   return false;
 275 }
 276
 277 printing::PrintJobManager* TestingBrowserProcess::print_job_manager() {
 278 #if defined(ENABLE_PRINTING)
 279   if (!print_job_manager_.get())
 280     print_job_manager_.reset(new printing::PrintJobManager());
 281   return print_job_manager_.get();
 282 #else
 283   NOTIMPLEMENTED();
 284   return nullptr;
 285 #endif
 286 }
 287
 288 printing::PrintPreviewDialogController*
 289 TestingBrowserProcess::print_preview_dialog_controller() {
 290 #if defined(ENABLE_PRINT_PREVIEW)
 291   if (!print_preview_dialog_controller_.get())
 292     print_preview_dialog_controller_ =
 293         new printing::PrintPreviewDialogController();
 294   return print_preview_dialog_controller_.get();
 295 #else
 296   NOTIMPLEMENTED();
 297   return nullptr;
 298 #endif
 299 }
 300
 301 printing::BackgroundPrintingManager*
 302 TestingBrowserProcess::background_printing_manager() {
 303 #if defined(ENABLE_PRINT_PREVIEW)
 304   if (!background_printing_manager_.get()) {
 305     background_printing_manager_.reset(
 306         new printing::BackgroundPrintingManager());
 307   }
 308   return background_printing_manager_.get();
 309 #else
 310   NOTIMPLEMENTED();
 311   return nullptr;
 312 #endif
 313 }
 314
 315 const std::string& TestingBrowserProcess::GetApplicationLocale() {
 316   return app_locale_;
 317 }
 318
 319 void TestingBrowserProcess::SetApplicationLocale(
 320     const std::string& app_locale) {
 321   app_locale_ = app_locale;
 322 }
 323
 324 DownloadStatusUpdater* TestingBrowserProcess::download_status_updater() {
 325   return nullptr;
 326 }
 327
 328 DownloadRequestLimiter* TestingBrowserProcess::download_request_limiter() {
 329   return nullptr;
 330 }
 331
 332 net_log::ChromeNetLog* TestingBrowserProcess::net_log() {
 333   return nullptr;
 334 }
 335
 336 component_updater::ComponentUpdateService*
 337 TestingBrowserProcess::component_updater() {
 338   return nullptr;
 339 }
 340
 341 CRLSetFetcher* TestingBrowserProcess::crl_set_fetcher() {
 342   return nullptr;
 343 }
 344
 345 component_updater::PnaclComponentInstaller*
 346 TestingBrowserProcess::pnacl_component_installer() {
 347   return nullptr;
 348 }
 349
 350 component_updater::SupervisedUserWhitelistInstaller*
 351 TestingBrowserProcess::supervised_user_whitelist_installer() {
 352   return nullptr;
 353 }
 354
 355 MediaFileSystemRegistry* TestingBrowserProcess::media_file_system_registry() {
 356 #if defined(OS_IOS) || defined(OS_ANDROID)
 357   NOTIMPLEMENTED();
 358   return nullptr;
 359 #else
 360   if (!media_file_system_registry_)
 361     media_file_system_registry_.reset(new MediaFileSystemRegistry());
 362   return media_file_system_registry_.get();
 363 #endif
 364 }
 365
 366 bool TestingBrowserProcess::created_local_state() const {
 367   return (local_state_ != nullptr);
 368 }
 369
 370 #if defined(ENABLE_WEBRTC)
 371 WebRtcLogUploader* TestingBrowserProcess::webrtc_log_uploader() {
 372   return nullptr;
 373 }
 374 #endif
 375
 376 network_time::NetworkTimeTracker*
 377 TestingBrowserProcess::network_time_tracker() {
 378   if (!network_time_tracker_) {
 379     DCHECK(local_state_);
 380     network_time_tracker_.reset(new network_time::NetworkTimeTracker(
 381         scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
 382         local_state_));
 383   }
 384   return network_time_tracker_.get();
 385 }
 386
 387 gcm::GCMDriver* TestingBrowserProcess::gcm_driver() {
 388   return nullptr;
 389 }
 390
 391 memory::OomPriorityManager* TestingBrowserProcess::GetOomPriorityManager() {
 392   return nullptr;
 393 }
 394
 395 ShellIntegration::DefaultWebClientState
 396 TestingBrowserProcess::CachedDefaultWebClientState() {
 397   return ShellIntegration::UNKNOWN_DEFAULT;
 398 }
 399 void TestingBrowserProcess::SetSystemRequestContext(
 400     net::URLRequestContextGetter* context_getter) {
 401   system_request_context_ = context_getter;
 402 }
 403
 404 void TestingBrowserProcess::SetNotificationUIManager(
 405     scoped_ptr<NotificationUIManager> notification_ui_manager) {
 406   notification_ui_manager_.swap(notification_ui_manager);
 407 }
 408
 409 void TestingBrowserProcess::SetLocalState(PrefService* local_state) {
 410   if (!local_state) {
 411     // The local_state_ PrefService is owned outside of TestingBrowserProcess,
 412     // but some of the members of TestingBrowserProcess hold references to it
 413     // (for example, via PrefNotifier members). But given our test
 414     // infrastructure which tears down individual tests before freeing the
 415     // TestingBrowserProcess, there's not a good way to make local_state outlive
 416     // these dependencies. As a workaround, whenever local_state_ is cleared
 417     // (assumedly as part of exiting the test and freeing TestingBrowserProcess)
 418     // any components owned by TestingBrowserProcess that depend on local_state
 419     // are also freed.
 420     network_time_tracker_.reset();
 421 #if !defined(OS_IOS)
 422     notification_ui_manager_.reset();
 423 #endif
 424 #if defined(ENABLE_CONFIGURATION_POLICY)
 425     ShutdownBrowserPolicyConnector();
 426     created_browser_policy_connector_ = false;
 427 #endif
 428   }
 429   local_state_ = local_state;
 430 }
 431
 432 void TestingBrowserProcess::SetIOThread(IOThread* io_thread) {
 433   io_thread_ = io_thread;
 434 }
 435
 436 void TestingBrowserProcess::ShutdownBrowserPolicyConnector() {
 437 #if defined(ENABLE_CONFIGURATION_POLICY)
 438   if (browser_policy_connector_)
 439     browser_policy_connector_->Shutdown();
 440   browser_policy_connector_.reset();
 441 #else
 442   CHECK(false);
 443 #endif
 444 }
 445
 446 void TestingBrowserProcess::SetSafeBrowsingService(
 447     SafeBrowsingService* sb_service) {
 448 #if defined(OS_IOS)
 449   NOTIMPLEMENTED();
 450 #else
 451   sb_service_ = sb_service;
 452 #endif
 453 }
 454
 455 ///////////////////////////////////////////////////////////////////////////////
 456
 457 TestingBrowserProcessInitializer::TestingBrowserProcessInitializer() {
 458   TestingBrowserProcess::CreateInstance();
 459 }
 460
 461 TestingBrowserProcessInitializer::~TestingBrowserProcessInitializer() {
 462   TestingBrowserProcess::DeleteInstance();
 463 }