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/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
  49 TestingBrowserProcess* TestingBrowserProcess::GetGlobal() {
  50   return static_cast<TestingBrowserProcess*>(g_browser_process);
  51 }
  52
  53 // static
  54 void TestingBrowserProcess::CreateInstance() {
  55   DCHECK(!g_browser_process);
  56   g_browser_process = new TestingBrowserProcess;
  57 }
  58
  59 // static
  60 void 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
  67 TestingBrowserProcess::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
  83 TestingBrowserProcess::~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
  97 void TestingBrowserProcess::ResourceDispatcherHostCreated() {
  98 }
  99
 100 void TestingBrowserProcess::EndSession() {
 101 }
 102
 103 MetricsServicesManager* TestingBrowserProcess::GetMetricsServicesManager() {
 104   return NULL;
 105 }
 106
 107 metrics::MetricsService* TestingBrowserProcess::metrics_service() {
 108   return NULL;
 109 }
 110
 111 rappor::RapporService* TestingBrowserProcess::rappor_service() {
 112   return NULL;
 113 }
 114
 115 IOThread* TestingBrowserProcess::io_thread() {
 116   return io_thread_;
 117 }
 118
 119 WatchDogThread* TestingBrowserProcess::watchdog_thread() {
 120   return NULL;
 121 }
 122
 123 ProfileManager* TestingBrowserProcess::profile_manager() {
 124 #if defined(OS_IOS)
 125   NOTIMPLEMENTED();
 126   return NULL;
 127 #else
 128   return profile_manager_.get();
 129 #endif
 130 }
 131
 132 void 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
 145 PrefService* TestingBrowserProcess::local_state() {
 146   return local_state_;
 147 }
 148
 149 chrome_variations::VariationsService*
 150     TestingBrowserProcess::variations_service() {
 151   return NULL;
 152 }
 153
 154 policy::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
 165 policy::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
 178 IconManager* TestingBrowserProcess::icon_manager() {
 179   return NULL;
 180 }
 181
 182 GLStringManager* TestingBrowserProcess::gl_string_manager() {
 183   return NULL;
 184 }
 185
 186 GpuModeManager* TestingBrowserProcess::gpu_mode_manager() {
 187   return NULL;
 188 }
 189
 190 BackgroundModeManager* TestingBrowserProcess::background_mode_manager() {
 191   return NULL;
 192 }
 193
 194 void TestingBrowserProcess::set_background_mode_manager_for_test(
 195     scoped_ptr<BackgroundModeManager> manager) {
 196   NOTREACHED();
 197 }
 198
 199 StatusTray* TestingBrowserProcess::status_tray() {
 200   return NULL;
 201 }
 202
 203 SafeBrowsingService* 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
 212 safe_browsing::ClientSideDetectionService*
 213 TestingBrowserProcess::safe_browsing_detection_service() {
 214   return NULL;
 215 }
 216
 217 net::URLRequestContextGetter* TestingBrowserProcess::system_request_context() {
 218   return system_request_context_;
 219 }
 220
 221 BrowserProcessPlatformPart* TestingBrowserProcess::platform_part() {
 222   return platform_part_.get();
 223 }
 224
 225 extensions::EventRouterForwarder*
 226 TestingBrowserProcess::extension_event_router_forwarder() {
 227   return NULL;
 228 }
 229
 230 NotificationUIManager* 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
 242 message_center::MessageCenter* TestingBrowserProcess::message_center() {
 243   return message_center::MessageCenter::Get();
 244 }
 245
 246 IntranetRedirectDetector* TestingBrowserProcess::intranet_redirect_detector() {
 247   return NULL;
 248 }
 249 void TestingBrowserProcess::CreateDevToolsHttpProtocolHandler(
 250     chrome::HostDesktopType host_desktop_type,
 251     const std::string& ip,
 252     int port) {
 253 }
 254
 255 unsigned int TestingBrowserProcess::AddRefModule() {
 256   return ++module_ref_count_;
 257 }
 258
 259 unsigned int TestingBrowserProcess::ReleaseModule() {
 260   DCHECK_GT(module_ref_count_, 0U);
 261   return --module_ref_count_;
 262 }
 263
 264 bool TestingBrowserProcess::IsShuttingDown() {
 265   return false;
 266 }
 267
 268 printing::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
 279 printing::PrintPreviewDialogController*
 280 TestingBrowserProcess::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
 292 printing::BackgroundPrintingManager*
 293 TestingBrowserProcess::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
 306 const std::string& TestingBrowserProcess::GetApplicationLocale() {
 307   return app_locale_;
 308 }
 309
 310 void TestingBrowserProcess::SetApplicationLocale(
 311     const std::string& app_locale) {
 312   app_locale_ = app_locale;
 313 }
 314
 315 DownloadStatusUpdater* TestingBrowserProcess::download_status_updater() {
 316   return NULL;
 317 }
 318
 319 DownloadRequestLimiter* TestingBrowserProcess::download_request_limiter() {
 320   return NULL;
 321 }
 322
 323 ChromeNetLog* TestingBrowserProcess::net_log() {
 324   return NULL;
 325 }
 326
 327 prerender::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
 338 component_updater::ComponentUpdateService*
 339 TestingBrowserProcess::component_updater() {
 340   return NULL;
 341 }
 342
 343 CRLSetFetcher* TestingBrowserProcess::crl_set_fetcher() {
 344   return NULL;
 345 }
 346
 347 component_updater::PnaclComponentInstaller*
 348 TestingBrowserProcess::pnacl_component_installer() {
 349   return NULL;
 350 }
 351
 352 MediaFileSystemRegistry* 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
 363 bool TestingBrowserProcess::created_local_state() const {
 364     return (local_state_ != NULL);
 365 }
 366
 367 #if defined(ENABLE_WEBRTC)
 368 WebRtcLogUploader* TestingBrowserProcess::webrtc_log_uploader() {
 369   return NULL;
 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 NULL;
 386 }
 387
 388 void TestingBrowserProcess::SetSystemRequestContext(
 389     net::URLRequestContextGetter* context_getter) {
 390   system_request_context_ = context_getter;
 391 }
 392
 393 void 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
 415 void TestingBrowserProcess::SetIOThread(IOThread* io_thread) {
 416   io_thread_ = io_thread;
 417 }
 418
 419 void 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
 431 void TestingBrowserProcess::SetSafeBrowsingService(
 432     SafeBrowsingService* sb_service) {
 433 #if !defined(OS_IOS)
 434   NOTIMPLEMENTED();
 435   sb_service_ = sb_service;
 436 #endif
 437 }
 438
 439 ///////////////////////////////////////////////////////////////////////////////
 440
 441 TestingBrowserProcessInitializer::TestingBrowserProcessInitializer() {
 442   TestingBrowserProcess::CreateInstance();
 443 }
 444
 445 TestingBrowserProcessInitializer::~TestingBrowserProcessInitializer() {
 446   TestingBrowserProcess::DeleteInstance();
 447 }