Replace deprecated base::NonThreadSafe in components/prefs in favor of SequenceChecker.

components/prefs/json_pref_store.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 "components/prefs/json_pref_store.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 144 matching lines @@
       filtering_in_progress_(false),
       pending_lossy_write_(false),
       read_error_(PREF_READ_ERROR_NONE),
       has_pending_write_reply_(false),
       write_count_histogram_(writer_.commit_interval(), path_) {
   DCHECK(!path_.empty());
 }
 
 bool JsonPrefStore::GetValue(const std::string& key,
                              const base::Value** result) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::Value* tmp = nullptr;
   if (!prefs_->Get(key, &tmp))
     return false;
 
   if (result)
     *result = tmp;
   return true;
 }
 
 std::unique_ptr<base::DictionaryValue> JsonPrefStore::GetValues() const {
   return prefs_->CreateDeepCopy();
 }
 
 void JsonPrefStore::AddObserver(PrefStore::Observer* observer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   observers_.AddObserver(observer);
 }
 
 void JsonPrefStore::RemoveObserver(PrefStore::Observer* observer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   observers_.RemoveObserver(observer);
 }
 
 bool JsonPrefStore::HasObservers() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return observers_.might_have_observers();
 }
 
 bool JsonPrefStore::IsInitializationComplete() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return initialized_;
 }
 
 bool JsonPrefStore::GetMutableValue(const std::string& key,
                                     base::Value** result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return prefs_->Get(key, result);
 }
 
 void JsonPrefStore::SetValue(const std::string& key,
                              std::unique_ptr<base::Value> value,
                              uint32_t flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ReportValueChanged(key, flags);
   }
 }
 
 void JsonPrefStore::SetValueSilently(const std::string& key,
                                      std::unique_ptr<base::Value> value,
                                      uint32_t flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(value);
   base::Value* old_value = nullptr;
   prefs_->Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     prefs_->Set(key, std::move(value));
     ScheduleWrite(flags);
   }
 }
 
 void JsonPrefStore::RemoveValue(const std::string& key, uint32_t flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (prefs_->RemovePath(key, nullptr))
     ReportValueChanged(key, flags);
 }
 
 void JsonPrefStore::RemoveValueSilently(const std::string& key,
                                         uint32_t flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   prefs_->RemovePath(key, nullptr);
   ScheduleWrite(flags);
 }
 
 bool JsonPrefStore::ReadOnly() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return read_only_;
 }
 
 PersistentPrefStore::PrefReadError JsonPrefStore::GetReadError() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return read_error_;
 }
 
 PersistentPrefStore::PrefReadError JsonPrefStore::ReadPrefs() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   OnFileRead(ReadPrefsFromDisk(path_));
   return filtering_in_progress_ ? PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE
                                 : read_error_;
 }
 
 void JsonPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   initialized_ = false;
   error_delegate_.reset(error_delegate);
 
   // Weakly binds the read task so that it doesn't kick in during shutdown.
   base::PostTaskAndReplyWithResult(
       sequenced_task_runner_.get(), FROM_HERE,
       base::Bind(&ReadPrefsFromDisk, path_),
       base::Bind(&JsonPrefStore::OnFileRead, AsWeakPtr()));
 }
 
 void JsonPrefStore::CommitPendingWrite() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Schedule a write for any lossy writes that are outstanding to ensure that
   // they get flushed when this function is called.
   SchedulePendingLossyWrites();
 
   if (writer_.HasPendingWrite() && !read_only_)
     writer_.DoScheduledWrite();
 }
 
 void JsonPrefStore::SchedulePendingLossyWrites() {
   if (pending_lossy_write_)
     writer_.ScheduleWrite(this);
 }
 
 void JsonPrefStore::ReportValueChanged(const std::string& key, uint32_t flags) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (pref_filter_)
     pref_filter_->FilterUpdate(key);
 
   for (PrefStore::Observer& observer : observers_)
     observer.OnPrefValueChanged(key);
 
   ScheduleWrite(flags);
 }
 
 void JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback(
     bool write_success) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   has_pending_write_reply_ = false;
   if (!on_next_successful_write_reply_.is_null()) {
     base::Closure on_successful_write =
         std::move(on_next_successful_write_reply_);
     if (write_success) {
       on_successful_write.Run();
     } else {
       RegisterOnNextSuccessfulWriteReply(on_successful_write);
     }
@@ skipping 10 matching lines @@
     on_next_write_callback.Run(write_success);
 
   // We can't run |on_next_write_reply| on the current thread. Bounce back to
   // the |reply_task_runner| which is the correct sequenced thread.
   reply_task_runner->PostTask(FROM_HERE,
                               base::Bind(on_next_write_reply, write_success));
 }
 
 void JsonPrefStore::RegisterOnNextSuccessfulWriteReply(
     const base::Closure& on_next_successful_write_reply) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(on_next_successful_write_reply_.is_null());
 
   on_next_successful_write_reply_ = on_next_successful_write_reply;
 
   // If there are pending callbacks, avoid erasing them; the reply will be used
   // as we set |on_next_successful_write_reply_|. Otherwise, setup a reply with
   // an empty callback.
   if (!has_pending_write_reply_) {
     has_pending_write_reply_ = true;
     writer_.RegisterOnNextWriteCallbacks(
         base::Closure(),
         base::Bind(
             &PostWriteCallback, base::Callback<void(bool success)>(),
             base::Bind(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback,
                        AsWeakPtr()),
             base::SequencedTaskRunnerHandle::Get()));
   }
 }
 
 void JsonPrefStore::RegisterOnNextWriteSynchronousCallbacks(
     OnWriteCallbackPair callbacks) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   has_pending_write_reply_ = true;
 
   writer_.RegisterOnNextWriteCallbacks(
       callbacks.first,
       base::Bind(
           &PostWriteCallback, callbacks.second,
           base::Bind(&JsonPrefStore::RunOrScheduleNextSuccessfulWriteCallback,
                      AsWeakPtr()),
           base::SequencedTaskRunnerHandle::Get()));
 }
 
 void JsonPrefStore::ClearMutableValues() {
   NOTIMPLEMENTED();
 }
 
 void JsonPrefStore::OnFileRead(std::unique_ptr<ReadResult> read_result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(read_result);
 
   std::unique_ptr<base::DictionaryValue> unfiltered_prefs(
       new base::DictionaryValue);
 
   read_error_ = read_result->error;
 
   bool initialization_successful = !read_result->no_dir;
 
@@ skipping 35 matching lines @@
             initialization_successful));
     pref_filter_->FilterOnLoad(post_filter_on_load_callback,
                                std::move(unfiltered_prefs));
   } else {
     FinalizeFileRead(initialization_successful, std::move(unfiltered_prefs),
                      false);
   }
 }
 
 JsonPrefStore::~JsonPrefStore() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CommitPendingWrite();
 }
 
 bool JsonPrefStore::SerializeData(std::string* output) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   pending_lossy_write_ = false;
 
   write_count_histogram_.RecordWriteOccured();
 
   if (pref_filter_) {
     OnWriteCallbackPair callbacks =
         pref_filter_->FilterSerializeData(prefs_.get());
     if (!callbacks.first.is_null() || !callbacks.second.is_null())
       RegisterOnNextWriteSynchronousCallbacks(callbacks);
   }
 
   JSONStringValueSerializer serializer(output);
   // Not pretty-printing prefs shrinks pref file size by ~30%. To obtain
   // readable prefs for debugging purposes, you can dump your prefs into any
   // command-line or online JSON pretty printing tool.
   serializer.set_pretty_print(false);
   bool success = serializer.Serialize(*prefs_);
   DCHECK(success);
   return success;
 }
 
 void JsonPrefStore::FinalizeFileRead(
     bool initialization_successful,
     std::unique_ptr<base::DictionaryValue> prefs,
     bool schedule_write) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   filtering_in_progress_ = false;
 
   if (!initialization_successful) {
     for (PrefStore::Observer& observer : observers_)
       observer.OnInitializationCompleted(false);
     return;
   }
 
   prefs_ = std::move(prefs);
@@ skipping 101 matching lines @@
   DCHECK_EQ(31, num_buckets);
 
   // The histogram below is an expansion of the UMA_HISTOGRAM_CUSTOM_COUNTS
   // macro adapted to allow for a dynamically suffixed histogram name.
   // Note: The factory creates and owns the histogram.
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       histogram_name, min_value, max_value, num_buckets,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   return histogram;
 }