Replace deprecated base::NonThreadSafe in chrome in favor of SequenceChecker.

chrome/browser/browser_process_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browser_process_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 260 matching lines @@
 
   update_client::UpdateQueryParams::SetDelegate(
       ChromeUpdateQueryParamsDelegate::GetInstance());
 
 #if !defined(OS_ANDROID)
   KeepAliveRegistry::GetInstance()->AddObserver(this);
 #endif  // !defined(OS_ANDROID)
 }
 
 BrowserProcessImpl::~BrowserProcessImpl() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extensions::ExtensionsBrowserClient::Set(nullptr);
 #endif
 
 #if !defined(OS_ANDROID)
   KeepAliveRegistry::GetInstance()->RemoveObserver(this);
 #endif  // !defined(OS_ANDROID)
 
   tracked_objects::ThreadData::EnsureCleanupWasCalled(4);
 
@@ skipping 244 matching lines @@
   for (auto& profile_writer_runner : profile_writer_runners)
     profile_write_rundown_counter->Post(profile_writer_runner.get());
   profile_write_rundown_counter->TimedWaitUntil(end_time);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 metrics_services_manager::MetricsServicesManager*
 BrowserProcessImpl::GetMetricsServicesManager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!metrics_services_manager_) {
     metrics_services_manager_.reset(
         new metrics_services_manager::MetricsServicesManager(
             base::MakeUnique<ChromeMetricsServicesManagerClient>(
                 local_state())));
   }
   return metrics_services_manager_.get();
 }
 
 metrics::MetricsService* BrowserProcessImpl::metrics_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return GetMetricsServicesManager()->GetMetricsService();
 }
 
 rappor::RapporServiceImpl* BrowserProcessImpl::rappor_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return GetMetricsServicesManager()->GetRapporServiceImpl();
 }
 
 ukm::UkmRecorder* BrowserProcessImpl::ukm_recorder() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return GetMetricsServicesManager()->GetUkmService();
 }
 
 IOThread* BrowserProcessImpl::io_thread() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(io_thread_.get());
   return io_thread_.get();
 }
 
 WatchDogThread* BrowserProcessImpl::watchdog_thread() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_watchdog_thread_)
     CreateWatchdogThread();
   DCHECK(watchdog_thread_.get() != NULL);
   return watchdog_thread_.get();
 }
 
 ProfileManager* BrowserProcessImpl::profile_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_profile_manager_)
     CreateProfileManager();
   return profile_manager_.get();
 }
 
 PrefService* BrowserProcessImpl::local_state() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_local_state_)
     CreateLocalState();
   return local_state_.get();
 }
 
 net::URLRequestContextGetter* BrowserProcessImpl::system_request_context() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return io_thread()->system_url_request_context_getter();
 }
 
 variations::VariationsService* BrowserProcessImpl::variations_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return GetMetricsServicesManager()->GetVariationsService();
 }
 
 BrowserProcessPlatformPart* BrowserProcessImpl::platform_part() {
   return platform_part_.get();
 }
 
 extensions::EventRouterForwarder*
 BrowserProcessImpl::extension_event_router_forwarder() {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   return extension_event_router_forwarder_.get();
 #else
   return NULL;
 #endif
 }
 
 NotificationUIManager* BrowserProcessImpl::notification_ui_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 // TODO(miguelg) return NULL for MAC as well once native notifications
 // are enabled by default.
 #if defined(OS_ANDROID)
   return nullptr;
 #else
   if (!created_notification_ui_manager_)
     CreateNotificationUIManager();
   return notification_ui_manager_.get();
 #endif
 }
 
 NotificationPlatformBridge* BrowserProcessImpl::notification_platform_bridge() {
 #if BUILDFLAG(ENABLE_NATIVE_NOTIFICATIONS)
   if (!created_notification_bridge_)
     CreateNotificationPlatformBridge();
   return notification_bridge_.get();
 #else
   return nullptr;
 #endif
 }
 
 message_center::MessageCenter* BrowserProcessImpl::message_center() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return message_center::MessageCenter::Get();
 }
 
 policy::BrowserPolicyConnector* BrowserProcessImpl::browser_policy_connector() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_browser_policy_connector_) {
     DCHECK(!browser_policy_connector_);
     browser_policy_connector_ = platform_part_->CreateBrowserPolicyConnector();
     created_browser_policy_connector_ = true;
   }
   return browser_policy_connector_.get();
 }
 
 policy::PolicyService* BrowserProcessImpl::policy_service() {
   return browser_policy_connector()->GetPolicyService();
 }
 
 IconManager* BrowserProcessImpl::icon_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_icon_manager_)
     CreateIconManager();
   return icon_manager_.get();
 }
 
 GpuProfileCache* BrowserProcessImpl::gpu_profile_cache() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!gpu_profile_cache_.get())
     gpu_profile_cache_.reset(GpuProfileCache::Create());
   return gpu_profile_cache_.get();
 }
 
 GpuModeManager* BrowserProcessImpl::gpu_mode_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!gpu_mode_manager_.get())
     gpu_mode_manager_.reset(new GpuModeManager());
   return gpu_mode_manager_.get();
 }
 
 void BrowserProcessImpl::CreateDevToolsHttpProtocolHandler(
     const std::string& ip,
     uint16_t port) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if !defined(OS_ANDROID)
   // StartupBrowserCreator::LaunchBrowser can be run multiple times when browser
   // is started with several profiles or existing browser process is reused.
   if (!remote_debugging_server_.get()) {
     remote_debugging_server_.reset(new RemoteDebuggingServer(ip, port));
   }
 #endif
 }
 
 void BrowserProcessImpl::CreateDevToolsAutoOpener() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if !defined(OS_ANDROID)
   // StartupBrowserCreator::LaunchBrowser can be run multiple times when browser
   // is started with several profiles or existing browser process is reused.
   if (!devtools_auto_opener_.get())
     devtools_auto_opener_.reset(new DevToolsAutoOpener());
 #endif
 }
 
 bool BrowserProcessImpl::IsShuttingDown() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // TODO(crbug.com/560486): Fix the tests that make the check of
   // |tearing_down_| necessary here.
   return shutting_down_ || tearing_down_;
 }
 
 printing::PrintJobManager* BrowserProcessImpl::print_job_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return print_job_manager_.get();
 }
 
 printing::PrintPreviewDialogController*
     BrowserProcessImpl::print_preview_dialog_controller() {
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!print_preview_dialog_controller_.get())
     CreatePrintPreviewDialogController();
   return print_preview_dialog_controller_.get();
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 printing::BackgroundPrintingManager*
     BrowserProcessImpl::background_printing_manager() {
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!background_printing_manager_.get())
     CreateBackgroundPrintingManager();
   return background_printing_manager_.get();
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 IntranetRedirectDetector* BrowserProcessImpl::intranet_redirect_detector() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!intranet_redirect_detector_.get())
     CreateIntranetRedirectDetector();
   return intranet_redirect_detector_.get();
 }
 
 const std::string& BrowserProcessImpl::GetApplicationLocale() {
   DCHECK(!locale_.empty());
   return locale_;
 }
 
@@ skipping 37 matching lines @@
   if (!network_time_tracker_) {
     network_time_tracker_.reset(new network_time::NetworkTimeTracker(
         base::WrapUnique(new base::DefaultClock()),
         base::WrapUnique(new base::DefaultTickClock()), local_state(),
         system_request_context()));
   }
   return network_time_tracker_.get();
 }
 
 gcm::GCMDriver* BrowserProcessImpl::gcm_driver() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!gcm_driver_)
     CreateGCMDriver();
   return gcm_driver_.get();
 }
 
 memory::TabManager* BrowserProcessImpl::GetTabManager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
   if (!tab_manager_.get())
     tab_manager_.reset(new memory::TabManager());
   return tab_manager_.get();
 #else
   return nullptr;
 #endif
 }
 
 shell_integration::DefaultWebClientState
 BrowserProcessImpl::CachedDefaultWebClientState() {
   return cached_default_web_client_state_;
 }
 
 physical_web::PhysicalWebDataSource*
 BrowserProcessImpl::GetPhysicalWebDataSource() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if defined(OS_ANDROID)
   if (!physical_web_data_source_) {
     CreatePhysicalWebDataSource();
     DCHECK(physical_web_data_source_);
   }
   return physical_web_data_source_.get();
 #else
   return nullptr;
 #endif
 }
@@ skipping 29 matching lines @@
   registry->RegisterBooleanPref(metrics::prefs::kMetricsReportingEnabled,
                                 GoogleUpdateSettings::GetCollectStatsConsent());
 
 #if defined(OS_ANDROID)
   registry->RegisterBooleanPref(
       prefs::kCrashReportingEnabled, false);
 #endif  // defined(OS_ANDROID)
 }
 
 DownloadRequestLimiter* BrowserProcessImpl::download_request_limiter() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!download_request_limiter_.get())
     download_request_limiter_ = new DownloadRequestLimiter();
   return download_request_limiter_.get();
 }
 
 BackgroundModeManager* BrowserProcessImpl::background_mode_manager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 #if BUILDFLAG(ENABLE_BACKGROUND)
   if (!background_mode_manager_.get())
     CreateBackgroundModeManager();
   return background_mode_manager_.get();
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 void BrowserProcessImpl::set_background_mode_manager_for_test(
     std::unique_ptr<BackgroundModeManager> manager) {
 #if BUILDFLAG(ENABLE_BACKGROUND)
   background_mode_manager_ = std::move(manager);
 #endif
 }
 
 StatusTray* BrowserProcessImpl::status_tray() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!status_tray_.get())
     CreateStatusTray();
   return status_tray_.get();
 }
 
 safe_browsing::SafeBrowsingService*
 BrowserProcessImpl::safe_browsing_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_safe_browsing_service_)
     CreateSafeBrowsingService();
   return safe_browsing_service_.get();
 }
 
 safe_browsing::ClientSideDetectionService*
     BrowserProcessImpl::safe_browsing_detection_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (safe_browsing_service())
     return safe_browsing_service()->safe_browsing_detection_service();
   return NULL;
 }
 
 subresource_filter::ContentRulesetService*
 BrowserProcessImpl::subresource_filter_ruleset_service() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!created_subresource_filter_ruleset_service_)
     CreateSubresourceFilterRulesetService();
   return subresource_filter_ruleset_service_.get();
 }
 
 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
 void BrowserProcessImpl::StartAutoupdateTimer() {
   autoupdate_timer_.Start(FROM_HERE,
       base::TimeDelta::FromHours(kUpdateCheckIntervalHours),
       this,
@@ skipping 375 matching lines @@
 
 void BrowserProcessImpl::CacheDefaultWebClientState() {
 #if defined(OS_CHROMEOS)
   cached_default_web_client_state_ = shell_integration::IS_DEFAULT;
 #elif !defined(OS_ANDROID)
   cached_default_web_client_state_ = shell_integration::GetDefaultBrowser();
 #endif
 }
 
 void BrowserProcessImpl::Pin() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // CHECK(!IsShuttingDown());
   if (IsShuttingDown()) {
     // TODO(crbug.com/113031, crbug.com/625646): Temporary instrumentation.
     base::debug::SetCrashKeyToStackTrace(crash_keys::kBrowserUnpinTrace,
                                          release_last_reference_callstack_);
     CHECK(false);
   }
 }
 
 void BrowserProcessImpl::Unpin() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   release_last_reference_callstack_ = base::debug::StackTrace();
 
   shutting_down_ = true;
 #if BUILDFLAG(ENABLE_PRINTING)
   // Wait for the pending print jobs to finish. Don't do this later, since
   // this might cause a nested run loop to run, and we don't want pending
   // tasks to run once teardown has started.
   print_job_manager_->Shutdown();
 #endif
 
@@ skipping 75 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)