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

components/policy/core/common/cloud/component_cloud_policy_service.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_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <unordered_map>
@@ skipping 282 matching lines @@
   core_->AddObserver(this);
   client->AddObserver(this);
 
   // Register the supported policy domain for being downloaded in future policy
   // fetches.
   client->AddPolicyTypeToFetch(policy_type_,
                                std::string() /* settings_entity_id */);
 }
 
 ComponentCloudPolicyService::~ComponentCloudPolicyService() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   schema_registry_->RemoveObserver(this);
   core_->store()->RemoveObserver(this);
   core_->RemoveObserver(this);
   if (core_->client())
     Disconnect();
 
   io_task_runner_->DeleteSoon(FROM_HERE,
                               external_policy_data_fetcher_backend_.release());
   backend_task_runner_->DeleteSoon(FROM_HERE, backend_.release());
 }
 
 // static
 bool ComponentCloudPolicyService::SupportsDomain(PolicyDomain domain) {
   return ComponentCloudPolicyStore::SupportsDomain(domain);
 }
 
 void ComponentCloudPolicyService::ClearCache() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Backend::ClearCache, base::Unretained(backend_.get())));
 }
 
 void ComponentCloudPolicyService::OnSchemaRegistryReady() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   UpdateFromSchemaRegistry();
 }
 
 void ComponentCloudPolicyService::OnSchemaRegistryUpdated(
     bool has_new_schemas) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   UpdateFromSchemaRegistry();
 }
 
 void ComponentCloudPolicyService::OnCoreConnected(CloudPolicyCore* core) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(core_, core);
   // Immediately update with any PolicyFetchResponses that the client may
   // already have.
   UpdateFromClient();
 }
 
 void ComponentCloudPolicyService::OnCoreDisconnecting(CloudPolicyCore* core) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(core_, core);
   Disconnect();
 }
 
 void ComponentCloudPolicyService::OnRefreshSchedulerStarted(
     CloudPolicyCore* core) {
   // Ignored.
 }
 
 void ComponentCloudPolicyService::OnStoreLoaded(CloudPolicyStore* store) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(core_->store(), store);
   UpdateFromSuperiorStore();
 }
 
 void ComponentCloudPolicyService::OnStoreError(CloudPolicyStore* store) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(core_->store(), store);
   UpdateFromSuperiorStore();
 }
 
 void ComponentCloudPolicyService::OnPolicyFetched(CloudPolicyClient* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(core_->client(), client);
   UpdateFromClient();
 }
 
 void ComponentCloudPolicyService::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Ignored; the registration state is tracked by looking at the
   // CloudPolicyStore instead.
 }
 
 void ComponentCloudPolicyService::OnClientError(CloudPolicyClient* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Ignored.
 }
 
 void ComponentCloudPolicyService::UpdateFromSuperiorStore() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DVLOG(2) << "Obtaining credentials from the superior policy store";
 
   const em::PolicyData* policy = core_->store()->policy();
   if (!policy || !policy->has_username() || !policy->has_request_token()) {
     // Clear the cache in case there is no policy or there are no credentials -
     // e.g. when the user signs out.
     backend_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Backend::ClearCache, base::Unretained(backend_.get())));
@@ skipping 16 matching lines @@
   }
 
   // Initialize the backend to load the initial policy if not done yet,
   // regardless of the signin state.
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Backend::InitIfNeeded, base::Unretained(backend_.get())));
 }
 
 void ComponentCloudPolicyService::UpdateFromClient() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (core_->client()->responses().empty()) {
     // The client's responses will be empty if it hasn't fetched policy from the
     // DMServer yet. Make sure we don't purge the caches in this case.
     return;
   }
 
   DVLOG(2) << "Obtaining fetched policies from the policy client";
 
   std::unique_ptr<ScopedResponseMap> valid_responses =
       base::MakeUnique<ScopedResponseMap>();
   for (const auto& response : core_->client()->responses()) {
     PolicyNamespace ns;
     if (!ToPolicyNamespace(response.first, &ns)) {
       DVLOG(1) << "Ignored policy with type = " << response.first.first;
       continue;
     }
     (*valid_responses)[ns] =
         base::MakeUnique<em::PolicyFetchResponse>(*response.second);
   }
 
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Backend::SetFetchedPolicy, base::Unretained(backend_.get()),
                  base::Passed(&valid_responses)));
 }
 
 void ComponentCloudPolicyService::UpdateFromSchemaRegistry() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!schema_registry_->IsReady()) {
     // Ignore notifications from the registry which is not ready yet.
     return;
   }
   DVLOG(2) << "Updating schema map";
   current_schema_map_ = schema_registry_->schema_map();
   FilterAndInstallPolicy();
 }
 
 void ComponentCloudPolicyService::Disconnect() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   core_->client()->RemoveObserver(this);
 
   // Unregister the policy domain from being downloaded in the future policy
   // fetches.
   core_->client()->RemovePolicyTypeToFetch(
       policy_type_, std::string() /* settings_entity_id */);
 }
 
 void ComponentCloudPolicyService::SetPolicy(
     std::unique_ptr<PolicyBundle> policy) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Store the current unfiltered policies.
   unfiltered_policy_ = std::move(policy);
 
   FilterAndInstallPolicy();
 }
 
 void ComponentCloudPolicyService::FilterAndInstallPolicy() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!unfiltered_policy_ || !current_schema_map_)
     return;
 
   // Make a copy in |policy_| and filter it and validate against the schemas;
   // this is what's passed to the outside world.
   policy_.CopyFrom(*unfiltered_policy_);
   current_schema_map_->FilterBundle(&policy_);
 
   policy_installed_ = true;
   DVLOG(1) << "Installed policy (count = "
            << std::distance(policy_.begin(), policy_.end()) << ")";
   delegate_->OnComponentCloudPolicyUpdated();
 }
 
 }  // namespace policy