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