Replace deprecated base::NonThreadSafe in chrome/browser/chromeos/policy in favor of SequenceChecke…

chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc

 // Copyright 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 "chrome/browser/chromeos/policy/cloud_external_data_manager_base.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 335 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> backend_task_runner,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : backend_task_runner_(backend_task_runner),
       io_task_runner_(io_task_runner),
       backend_(new Backend(get_policy_details,
                            backend_task_runner_,
                            base::ThreadTaskRunnerHandle::Get())) {
 }
 
 CloudExternalDataManagerBase::~CloudExternalDataManagerBase() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   io_task_runner_->DeleteSoon(FROM_HERE,
                               external_policy_data_fetcher_backend_.release());
   backend_task_runner_->DeleteSoon(FROM_HERE, backend_.release());
 }
 
 void CloudExternalDataManagerBase::SetExternalDataStore(
     std::unique_ptr<CloudExternalDataStore> external_data_store) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::SetExternalDataStore,
       base::Unretained(backend_.get()),
       base::Passed(&external_data_store)));
 }
 
 void CloudExternalDataManagerBase::SetPolicyStore(
     CloudPolicyStore* policy_store) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CloudExternalDataManager::SetPolicyStore(policy_store);
   if (policy_store_ && policy_store_->is_initialized())
     OnPolicyStoreLoaded();
 }
 
 void CloudExternalDataManagerBase::OnPolicyStoreLoaded() {
   // Collect all external data references made by policies in |policy_store_|
   // and pass them to the |backend_|.
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::unique_ptr<Metadata> metadata(new Metadata);
   const PolicyMap& policy_map = policy_store_->policy_map();
   for (PolicyMap::const_iterator it = policy_map.begin();
        it != policy_map.end(); ++it) {
     if (!it->second.external_data_fetcher) {
       // Skip policies that do not reference external data.
       continue;
     }
     const base::DictionaryValue* dict = NULL;
     std::string url;
@@ skipping 12 matching lines @@
   }
 
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::OnMetadataUpdated,
       base::Unretained(backend_.get()),
       base::Passed(&metadata)));
 }
 
 void CloudExternalDataManagerBase::Connect(
     scoped_refptr<net::URLRequestContextGetter> request_context) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!external_policy_data_fetcher_backend_);
   external_policy_data_fetcher_backend_.reset(
       new ExternalPolicyDataFetcherBackend(io_task_runner_,
                                            request_context));
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::Connect,
       base::Unretained(backend_.get()),
       base::Passed(external_policy_data_fetcher_backend_->CreateFrontend(
           backend_task_runner_))));
 }
 
 void CloudExternalDataManagerBase::Disconnect() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   io_task_runner_->DeleteSoon(FROM_HERE,
                               external_policy_data_fetcher_backend_.release());
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::Disconnect, base::Unretained(backend_.get())));
 }
 
 void CloudExternalDataManagerBase::Fetch(
     const std::string& policy,
     const ExternalDataFetcher::FetchCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::Fetch, base::Unretained(backend_.get()), policy, callback));
 }
 
 // static
 void CloudExternalDataManagerBase::SetMaxExternalDataSizeForTesting(
     int max_size) {
   g_max_external_data_size_for_testing = max_size;
 }
 
 void CloudExternalDataManagerBase::FetchAll() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::FetchAll, base::Unretained(backend_.get())));
 }
 
 }  // namespace policy