[Cleanup] Use a sequence checker rather than a thread checker for the metrics service.

chrome/browser/metrics/chrome_metrics_service_client.cc

 // Copyright 2014 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/metrics/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
@@ skipping 298 matching lines @@
 #endif
 #if defined(OS_WIN)
       google_update_metrics_provider_(nullptr),
       watcher_metrics_provider_(nullptr),
       antivirus_metrics_provider_(nullptr),
 #endif
       drive_metrics_provider_(nullptr),
       start_time_(base::TimeTicks::Now()),
       has_uploaded_profiler_data_(false),
       weak_ptr_factory_(this) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   RecordCommandLineMetrics();
   RegisterForNotifications();
 }
 
 ChromeMetricsServiceClient::~ChromeMetricsServiceClient() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::GlobalHistogramAllocator* allocator =
       base::GlobalHistogramAllocator::Get();
   if (allocator) {
     // A normal shutdown is almost complete so there is no benefit in keeping a
     // file with no new data to be processed during the next startup sequence.
     // Deleting the file during shutdown adds an extra disk-access or two to
     // shutdown but eliminates the unnecessary processing of the contents during
     // startup only to find nothing.
     allocator->DeletePersistentLocation();
   }
@@ skipping 174 matching lines @@
   // |task.Run()| can be asynchronous or synchronous. For the latter case, we
   // may recurse back to this function. Therefore we must pop_front() first.
   initialize_task_queue_.pop_front();
   // Assumes this causes |OnInitNextTask()| to be called again for all but the
   // last task in |initialize_task_queue_|.
   task.Run();
 }
 
 void ChromeMetricsServiceClient::CollectFinalMetricsForLog(
     const base::Closure& done_callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   collect_final_metrics_done_callback_ = done_callback;
 
   if (ShouldIncludeProfilerDataInLog()) {
     // Fetch profiler data. This will call into
     // |FinishedReceivingProfilerData()| when the task completes.
     metrics::TrackingSynchronizer::FetchProfilerDataAsynchronously(
         weak_ptr_factory_.GetWeakPtr());
   } else {
     CollectFinalHistograms();
@@ skipping 252 matching lines @@
       process_data_phase, attributes.process_id, attributes.process_type,
       attributes.profiling_phase, attributes.phase_start - start_time_,
       attributes.phase_finish - start_time_, past_events);
 }
 
 void ChromeMetricsServiceClient::FinishedReceivingProfilerData() {
   CollectFinalHistograms();
 }
 
 void ChromeMetricsServiceClient::CollectFinalHistograms() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Begin the multi-step process of collecting memory usage histograms:
   // First spawn a task to collect the memory details; when that task is
   // finished, it will call OnMemoryDetailCollectionDone. That will in turn
   // call HistogramSynchronization to collect histograms from all renderers and
   // then call OnHistogramSynchronizationDone to continue processing.
   DCHECK(!waiting_for_collect_final_metrics_step_);
   waiting_for_collect_final_metrics_step_ = true;
 
   base::Closure callback =
       base::Bind(&ChromeMetricsServiceClient::OnMemoryDetailCollectionDone,
                  weak_ptr_factory_.GetWeakPtr());
 
   scoped_refptr<MetricsMemoryDetails> details(
       new MetricsMemoryDetails(callback, &memory_growth_tracker_));
   details->StartFetch();
 
   scoped_refptr<ProcessMemoryMetricsEmitter> emitter(
       new ProcessMemoryMetricsEmitter);
   emitter->FetchAndEmitProcessMemoryMetrics();
 }
 
 void ChromeMetricsServiceClient::OnMemoryDetailCollectionDone() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // This function should only be called as the callback from an ansynchronous
   // step.
   DCHECK(waiting_for_collect_final_metrics_step_);
 
   // Create a callback_task for OnHistogramSynchronizationDone.
   base::Closure callback = base::Bind(
       &ChromeMetricsServiceClient::OnHistogramSynchronizationDone,
       weak_ptr_factory_.GetWeakPtr());
 
@@ skipping 24 matching lines @@
       callback);
 
   // Set up the callback task to call after we receive histograms from all
   // child processes. |timeout| specifies how long to wait before absolutely
   // calling us back on the task.
   content::FetchHistogramsAsynchronously(base::ThreadTaskRunnerHandle::Get(),
                                          callback, timeout);
 }
 
 void ChromeMetricsServiceClient::OnHistogramSynchronizationDone() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // This function should only be called as the callback from an ansynchronous
   // step.
   DCHECK(waiting_for_collect_final_metrics_step_);
   DCHECK_GT(num_async_histogram_fetches_in_progress_, 0);
 
   // Check if all expected requests finished.
   if (--num_async_histogram_fetches_in_progress_ > 0)
     return;
 
@@ skipping 77 matching lines @@
   browser_sync::ProfileSyncService* sync =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
   if (sync)
     ObserveServiceForSyncDisables(static_cast<syncer::SyncService*>(sync));
 }
 
 void ChromeMetricsServiceClient::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   switch (type) {
     case chrome::NOTIFICATION_BROWSER_OPENED:
       // May have opened an incognito window.
       UpdateRunningServices();
       metrics_service_->OnApplicationNotIdle();
       break;
     case chrome::NOTIFICATION_BROWSER_CLOSED:
     case chrome::NOTIFICATION_TAB_PARENTED:
     case chrome::NOTIFICATION_TAB_CLOSING:
@@ skipping 37 matching lines @@
     ukm_service_->Purge();
     ukm_service_->ResetClientId();
   }
   // Signal service manager to enable/disable UKM based on new state.
   UpdateRunningServices();
 }
 
 bool ChromeMetricsServiceClient::IsHistorySyncEnabledOnAllProfiles() {
   return SyncDisableObserver::IsHistorySyncEnabledOnAllProfiles();
 }