Replace deprecated base::NonThreadSafe in chrome/browser/chromeos/settings in favor of SequenceChec…

chrome/browser/chromeos/settings/cros_settings.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/chromeos/settings/cros_settings.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 65 matching lines @@
     AddSettingsProvider(base::MakeUnique<StubCrosSettingsProvider>(notify_cb));
   } else {
     AddSettingsProvider(base::MakeUnique<DeviceSettingsProvider>(
         notify_cb, device_settings_service));
   }
   // System settings are not mocked currently.
   AddSettingsProvider(base::MakeUnique<SystemSettingsProvider>(notify_cb));
 }
 
 CrosSettings::~CrosSettings() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 bool CrosSettings::IsCrosSettings(const std::string& path) {
   return base::StartsWith(path, kCrosSettingsPrefix,
                           base::CompareCase::SENSITIVE);
 }
 
 void CrosSettings::Set(const std::string& path, const base::Value& in_value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CrosSettingsProvider* provider;
   provider = GetProvider(path);
   if (provider)
     provider->Set(path, in_value);
 }
 
 const base::Value* CrosSettings::GetPref(const std::string& path) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CrosSettingsProvider* provider = GetProvider(path);
   if (provider)
     return provider->Get(path);
   NOTREACHED() << path << " preference was not found in the signed settings.";
   return nullptr;
 }
 
 CrosSettingsProvider::TrustedStatus CrosSettings::PrepareTrustedValues(
     const base::Closure& callback) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (size_t i = 0; i < providers_.size(); ++i) {
     CrosSettingsProvider::TrustedStatus status =
         providers_[i]->PrepareTrustedValues(callback);
     if (status != CrosSettingsProvider::TRUSTED)
       return status;
   }
   return CrosSettingsProvider::TRUSTED;
 }
 
 void CrosSettings::SetBoolean(const std::string& path, bool in_value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::Value value(in_value);
   Set(path, value);
 }
 
 void CrosSettings::SetInteger(const std::string& path, int in_value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::Value value(in_value);
   Set(path, value);
 }
 
 void CrosSettings::SetDouble(const std::string& path, double in_value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::Value value(in_value);
   Set(path, value);
 }
 
 void CrosSettings::SetString(const std::string& path,
                              const std::string& in_value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   base::Value value(in_value);
   Set(path, value);
 }
 
 void CrosSettings::AppendToList(const std::string& path,
                                 const base::Value* value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* old_value = GetPref(path);
   std::unique_ptr<base::Value> new_value(old_value ? old_value->DeepCopy()
                                                    : new base::ListValue());
   static_cast<base::ListValue*>(new_value.get())
       ->Append(value->CreateDeepCopy());
   Set(path, *new_value);
 }
 
 void CrosSettings::RemoveFromList(const std::string& path,
                                   const base::Value* value) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* old_value = GetPref(path);
   std::unique_ptr<base::Value> new_value(old_value ? old_value->DeepCopy()
                                                    : new base::ListValue());
   static_cast<base::ListValue*>(new_value.get())->Remove(*value, nullptr);
   Set(path, *new_value);
 }
 
 bool CrosSettings::GetBoolean(const std::string& path,
                               bool* bool_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsBoolean(bool_value);
   return false;
 }
 
 bool CrosSettings::GetInteger(const std::string& path,
                               int* out_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsInteger(out_value);
   return false;
 }
 
 bool CrosSettings::GetDouble(const std::string& path,
                              double* out_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsDouble(out_value);
   return false;
 }
 
 bool CrosSettings::GetString(const std::string& path,
                              std::string* out_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsString(out_value);
   return false;
 }
 
 bool CrosSettings::GetList(const std::string& path,
                            const base::ListValue** out_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsList(out_value);
   return false;
 }
 
 bool CrosSettings::GetDictionary(
     const std::string& path,
     const base::DictionaryValue** out_value) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const base::Value* value = GetPref(path);
   if (value)
     return value->GetAsDictionary(out_value);
   return false;
 }
 
 bool CrosSettings::FindEmailInList(const std::string& path,
                                    const std::string& email,
                                    bool* wildcard_match) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::string canonicalized_email(
       gaia::CanonicalizeEmail(gaia::SanitizeEmail(email)));
   std::string wildcard_email;
   std::string::size_type at_pos = canonicalized_email.find('@');
   if (at_pos != std::string::npos) {
     wildcard_email =
         std::string("*").append(canonicalized_email.substr(at_pos));
   }
 
   if (wildcard_match)
@@ skipping 27 matching lines @@
   }
 
   if (wildcard_match)
     *wildcard_match = found_wildcard_match;
 
   return found_wildcard_match;
 }
 
 bool CrosSettings::AddSettingsProvider(
     std::unique_ptr<CrosSettingsProvider> provider) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CrosSettingsProvider* provider_ptr = provider.get();
   providers_.push_back(std::move(provider));
 
   // Allow the provider to notify this object when settings have changed.
   // Providers instantiated inside this class will have the same callback
   // passed to their constructor, but doing it here allows for providers
   // to be instantiated outside this class.
   CrosSettingsProvider::NotifyObserversCallback notify_cb(
       base::Bind(&CrosSettings::FireObservers, base::Unretained(this)));
   provider_ptr->SetNotifyObserversCallback(notify_cb);
   return true;
 }
 
 std::unique_ptr<CrosSettingsProvider> CrosSettings::RemoveSettingsProvider(
     CrosSettingsProvider* provider) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = std::find_if(
       providers_.begin(), providers_.end(),
       [provider](const std::unique_ptr<CrosSettingsProvider>& ptr) {
         return ptr.get() == provider;
       });
   if (it != providers_.end()) {
     std::unique_ptr<CrosSettingsProvider> ptr = std::move(*it);
     providers_.erase(it);
     return ptr;
   }
   return nullptr;
 }
 
 std::unique_ptr<CrosSettings::ObserverSubscription>
 CrosSettings::AddSettingsObserver(const std::string& path,
                                   const base::Closure& callback) {
   DCHECK(!path.empty());
   DCHECK(!callback.is_null());
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!GetProvider(path)) {
     NOTREACHED() << "Trying to add an observer for an unregistered setting: "
                  << path;
     return std::unique_ptr<CrosSettings::ObserverSubscription>();
   }
 
   // Get the callback registry associated with the path.
   base::CallbackList<void(void)>* registry = nullptr;
   auto observer_iterator = settings_observers_.find(path);
@@ skipping 11 matching lines @@
 CrosSettingsProvider* CrosSettings::GetProvider(
     const std::string& path) const {
   for (size_t i = 0; i < providers_.size(); ++i) {
     if (providers_[i]->HandlesSetting(path))
       return providers_[i].get();
   }
   return nullptr;
 }
 
 void CrosSettings::FireObservers(const std::string& path) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto observer_iterator = settings_observers_.find(path);
   if (observer_iterator == settings_observers_.end())
     return;
 
   observer_iterator->second->Notify();
 }
 
 ScopedTestCrosSettings::ScopedTestCrosSettings() {
   CrosSettings::Initialize();
 }
 
 ScopedTestCrosSettings::~ScopedTestCrosSettings() {
   CrosSettings::Shutdown();
 }
 
 }  // namespace chromeos