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 } 448