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

components/policy/core/common/cloud/component_cloud_policy_store.cc

 // Copyright (c) 2013 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/policy/core/common/cloud/component_cloud_policy_store.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 ComponentCloudPolicyStore::Delegate::~Delegate() {}
 
 ComponentCloudPolicyStore::ComponentCloudPolicyStore(Delegate* delegate,
                                                      ResourceCache* cache)
     : delegate_(delegate), cache_(cache) {
   // Allow the store to be created on a different thread than the thread that
   // will end up using it.
-  DetachFromThread();
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
 ComponentCloudPolicyStore::~ComponentCloudPolicyStore() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 // static
 bool ComponentCloudPolicyStore::SupportsDomain(PolicyDomain domain) {
   return GetDomainConstants(domain) != nullptr;
 }
 
 // static
 bool ComponentCloudPolicyStore::GetPolicyType(PolicyDomain domain,
                                               std::string* policy_type) {
   const DomainConstants* constants = GetDomainConstants(domain);
   if (constants)
     *policy_type = constants->policy_type;
   return constants != nullptr;
 }
 
 // static
 bool ComponentCloudPolicyStore::GetPolicyDomain(const std::string& policy_type,
                                                 PolicyDomain* domain) {
   const DomainConstants* constants = GetDomainConstantsForType(policy_type);
   if (constants)
     *domain = constants->domain;
   return constants != nullptr;
 }
 
 const std::string& ComponentCloudPolicyStore::GetCachedHash(
     const PolicyNamespace& ns) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::map<PolicyNamespace, std::string>::const_iterator it =
       cached_hashes_.find(ns);
   return it == cached_hashes_.end() ? base::EmptyString() : it->second;
 }
 
 void ComponentCloudPolicyStore::SetCredentials(const std::string& username,
                                                const std::string& dm_token,
                                                const std::string& device_id,
                                                const std::string& public_key,
                                                int public_key_version) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(username_.empty() || username == username_);
   DCHECK(dm_token_.empty() || dm_token == dm_token_);
   DCHECK(device_id_.empty() || device_id == device_id_);
   username_ = username;
   dm_token_ = dm_token;
   device_id_ = device_id;
   public_key_ = public_key;
   public_key_version_ = public_key_version;
 }
 
 void ComponentCloudPolicyStore::Load() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   typedef std::map<std::string, std::string> ContentMap;
 
   // Load all cached policy protobufs for each domain.
   for (const DomainConstants& constants : kDomains) {
     ContentMap protos;
     cache_->LoadAllSubkeys(constants.proto_cache_key, &protos);
     for (ContentMap::iterator it = protos.begin(); it != protos.end(); ++it) {
       const std::string& id(it->first);
       const PolicyNamespace ns(constants.domain, id);
 
@@ skipping 25 matching lines @@
     }
   }
 }
 
 bool ComponentCloudPolicyStore::Store(
     const PolicyNamespace& ns,
     const std::string& serialized_policy,
     std::unique_ptr<em::PolicyData> policy_data,
     const std::string& secure_hash,
     const std::string& data) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const DomainConstants* constants = GetDomainConstants(ns.domain);
   PolicyMap policy;
   // |serialized_policy| has already been validated; validate the data now.
   if (!constants)
     return false;
   if (!ValidateData(data, secure_hash, &policy))
     return false;
 
   // Flush the proto and the data to the cache.
   cache_->Store(constants->proto_cache_key, ns.component_id, serialized_policy);
   cache_->Store(constants->data_cache_key, ns.component_id, data);
   // And expose the policy.
   policy_bundle_.Get(ns).Swap(&policy);
   cached_hashes_[ns] = secure_hash;
   stored_policy_times_[ns] = base::Time::FromJavaTime(policy_data->timestamp());
   delegate_->OnComponentCloudPolicyStoreUpdated();
   return true;
 }
 
 void ComponentCloudPolicyStore::Delete(const PolicyNamespace& ns) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const DomainConstants* constants = GetDomainConstants(ns.domain);
   if (!constants)
     return;
 
   cache_->Delete(constants->proto_cache_key, ns.component_id);
   cache_->Delete(constants->data_cache_key, ns.component_id);
 
   if (!policy_bundle_.Get(ns).empty()) {
     policy_bundle_.Get(ns).Clear();
     delegate_->OnComponentCloudPolicyStoreUpdated();
   }
 }
 
 void ComponentCloudPolicyStore::Purge(
     PolicyDomain domain,
     const ResourceCache::SubkeyFilter& filter) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const DomainConstants* constants = GetDomainConstants(domain);
   if (!constants)
     return;
 
   cache_->FilterSubkeys(constants->proto_cache_key, filter);
   cache_->FilterSubkeys(constants->data_cache_key, filter);
 
   // Stop serving policies for purged namespaces.
   bool purged_current_policies = false;
   for (PolicyBundle::const_iterator it = policy_bundle_.begin();
@@ skipping 163 matching lines @@
     // this must support a configurable scope; assuming POLICY_SCOPE_USER is
     // fine for now.
     policy->Set(it.key(), level, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
                 std::move(value), nullptr);
   }
 
   return true;
 }
 
 }  // namespace policy