Replace deprecated base::NonThreadSafe in chrome/browser/metrics/perf in favor of SequenceChecker.

chrome/browser/metrics/perf/perf_provider_chromeos.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/metrics/perf/perf_provider_chromeos.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <map>
 #include <string>
@@ skipping 298 matching lines @@
     base::TimeDelta max_collection_delay)
     : sampling_factor_(sampling_factor),
       max_collection_delay_(max_collection_delay.ToInternalValue()) {}
 
 PerfProvider::PerfProvider()
     : login_observer_(this),
       weak_factory_(this) {
 }
 
 PerfProvider::~PerfProvider() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   chromeos::LoginState::Get()->RemoveObserver(&login_observer_);
 }
 
 void PerfProvider::Init() {
   CHECK(command_selector_.SetOdds(
       internal::GetDefaultCommandsForCpu(GetCPUIdentity())));
   std::map<std::string, std::string> params;
   if (variations::GetVariationParams(kCWPFieldTrialName, &params))
     SetCollectionParamsFromVariationParams(params);
 
@@ skipping 124 matching lines @@
     if (!(base::StringToDouble(weight_str, &weight) && weight > 0.0))
       continue;  // Just drop invalid commands.
     std::string command(val.begin() + split + 1, val.end());
     commands.push_back(RandomSelector::WeightAndValue(weight, command));
   }
   command_selector_.SetOdds(commands);
 }
 
 bool PerfProvider::GetSampledProfiles(
     std::vector<SampledProfile>* sampled_profiles) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (cached_perf_data_.empty()) {
     AddToPerfHistogram(NOT_READY_TO_UPLOAD);
     return false;
   }
 
   sampled_profiles->swap(cached_perf_data_);
   cached_perf_data_.clear();
 
   AddToPerfHistogram(SUCCESS);
   return true;
@@ skipping 14 matching lines @@
   }
 
   return PerfSubcommand::PERF_COMMAND_UNSUPPORTED;
 }
 
 void PerfProvider::ParseOutputProtoIfValid(
     std::unique_ptr<WindowedIncognitoObserver> incognito_observer,
     std::unique_ptr<SampledProfile> sampled_profile,
     PerfSubcommand subcommand,
     const std::string& perf_stdout) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // |perf_output_call_| called us, and owns |perf_stdout|. We must delete it,
   // but not before parsing |perf_stdout|, and we may return early.
   std::unique_ptr<PerfOutputCall> call_deleter(std::move(perf_output_call_));
 
   if (incognito_observer->incognito_launched()) {
     AddToPerfHistogram(INCOGNITO_LAUNCHED);
     return;
   }
 
@@ skipping 130 matching lines @@
   next_profiling_interval_start_ = now;
   ScheduleIntervalCollection();
 }
 
 void PerfProvider::Deactivate() {
   // Stop the timer, but leave |cached_perf_data_| intact.
   timer_.Stop();
 }
 
 void PerfProvider::ScheduleIntervalCollection() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (timer_.IsRunning())
     return;
 
   const base::TimeTicks now = base::TimeTicks::Now();
 
   base::TimeTicks interval_end =
       next_profiling_interval_start_ + collection_params_.periodic_interval();
   if (now > interval_end) {
     // We somehow missed at least one window. Start over.
     next_profiling_interval_start_ = now;
@@ skipping 11 matching lines @@
 
   timer_.Start(FROM_HERE, scheduled_time - now, this,
                &PerfProvider::DoPeriodicCollection);
 
   // Update the profiling interval tracker to the start of the next interval.
   next_profiling_interval_start_ = interval_end;
 }
 
 void PerfProvider::CollectIfNecessary(
     std::unique_ptr<SampledProfile> sampled_profile) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Schedule another interval collection. This call makes sense regardless of
   // whether or not the current collection was interval-triggered. If it had
   // been another type of trigger event, the interval timer would have been
   // halted, so it makes sense to reschedule a new interval collection.
   ScheduleIntervalCollection();
 
   // Only allow one active collection.
   if (perf_output_call_) {
     AddToPerfHistogram(ALREADY_COLLECTING);
@@ skipping 60 matching lines @@
   std::unique_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESTORE_SESSION);
   sampled_profile->set_ms_after_restore(time_after_restore.InMilliseconds());
   sampled_profile->set_num_tabs_restored(num_tabs_restored);
 
   CollectIfNecessary(std::move(sampled_profile));
   last_session_restore_collection_time_ = base::TimeTicks::Now();
 }
 
 }  // namespace metrics