Deprecate NonThreadSafe in net/ in favor of SequenceChecker/ThreadChecker.

net/ssl/default_channel_id_store.cc

 // Copyright 2014 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 "net/ssl/default_channel_id_store.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 209 matching lines @@
     PersistentStore* store)
     : initialized_(false),
       loaded_(false),
       store_(store),
       weak_ptr_factory_(this) {}
 
 int DefaultChannelIDStore::GetChannelID(
     const std::string& server_identifier,
     std::unique_ptr<crypto::ECPrivateKey>* key_result,
     const GetChannelIDCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   InitIfNecessary();
 
   if (!loaded_) {
     EnqueueTask(std::unique_ptr<Task>(
         new GetChannelIDTask(server_identifier, callback)));
     return ERR_IO_PENDING;
   }
 
   ChannelIDMap::iterator it = channel_ids_.find(server_identifier);
 
@@ skipping 37 matching lines @@
 void DefaultChannelIDStore::GetAllChannelIDs(
     const GetChannelIDListCallback& callback) {
   RunOrEnqueueTask(std::unique_ptr<Task>(new GetAllChannelIDsTask(callback)));
 }
 
 void DefaultChannelIDStore::Flush() {
   store_->Flush();
 }
 
 int DefaultChannelIDStore::GetChannelIDCount() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   return channel_ids_.size();
 }
 
 void DefaultChannelIDStore::SetForceKeepSessionState() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   InitIfNecessary();
 
   if (store_)
     store_->SetForceKeepSessionState();
 }
 
 DefaultChannelIDStore::~DefaultChannelIDStore() {
   DeleteAllInMemory();
 }
 
 void DefaultChannelIDStore::DeleteAllInMemory() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end(); ++it) {
     delete it->second;
   }
   channel_ids_.clear();
 }
 
 void DefaultChannelIDStore::InitStore() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(store_) << "Store must exist to initialize";
   DCHECK(!loaded_);
 
   store_->Load(base::Bind(&DefaultChannelIDStore::OnLoaded,
                           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DefaultChannelIDStore::OnLoaded(
     std::unique_ptr<std::vector<std::unique_ptr<ChannelID>>> channel_ids) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (std::vector<std::unique_ptr<ChannelID>>::iterator it =
            channel_ids->begin();
        it != channel_ids->end(); ++it) {
     DCHECK(channel_ids_.find((*it)->server_identifier()) ==
            channel_ids_.end());
     std::string ident = (*it)->server_identifier();
     channel_ids_[ident] = it->release();
   }
   channel_ids->clear();
 
   loaded_ = true;
 
   for (std::unique_ptr<Task>& i : waiting_tasks_)
     i->Run(this);
   waiting_tasks_.clear();
 }
 
 void DefaultChannelIDStore::SyncSetChannelID(
     std::unique_ptr<ChannelID> channel_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
 
   InternalDeleteChannelID(channel_id->server_identifier());
   InternalInsertChannelID(std::move(channel_id));
 }
 
 void DefaultChannelIDStore::SyncDeleteChannelID(
     const std::string& server_identifier) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
   InternalDeleteChannelID(server_identifier);
 }
 
 void DefaultChannelIDStore::SyncDeleteForDomainsCreatedBetween(
     const base::Callback<bool(const std::string&)>& domain_predicate,
     base::Time delete_begin,
     base::Time delete_end) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end();) {
     ChannelIDMap::iterator cur = it;
     ++it;
     ChannelID* channel_id = cur->second;
 
     if ((delete_begin.is_null() ||
          channel_id->creation_time() >= delete_begin) &&
         (delete_end.is_null() || channel_id->creation_time() < delete_end) &&
         domain_predicate.Run(channel_id->server_identifier())) {
       if (store_)
         store_->DeleteChannelID(*channel_id);
       delete channel_id;
       channel_ids_.erase(cur);
     }
   }
 }
 
 void DefaultChannelIDStore::SyncGetAllChannelIDs(
     ChannelIDList* channel_id_list) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end(); ++it)
     channel_id_list->push_back(*it->second);
 }
 
 void DefaultChannelIDStore::EnqueueTask(std::unique_ptr<Task> task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!loaded_);
   waiting_tasks_.push_back(std::move(task));
 }
 
 void DefaultChannelIDStore::RunOrEnqueueTask(std::unique_ptr<Task> task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   InitIfNecessary();
 
   if (!loaded_) {
     EnqueueTask(std::move(task));
     return;
   }
 
   task->Run(this);
 }
 
 void DefaultChannelIDStore::InternalDeleteChannelID(
     const std::string& server_identifier) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
 
   ChannelIDMap::iterator it = channel_ids_.find(server_identifier);
   if (it == channel_ids_.end())
     return;  // There is nothing to delete.
 
   ChannelID* channel_id = it->second;
   if (store_)
     store_->DeleteChannelID(*channel_id);
   channel_ids_.erase(it);
   delete channel_id;
 }
 
 void DefaultChannelIDStore::InternalInsertChannelID(
     std::unique_ptr<ChannelID> channel_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(loaded_);
 
   if (store_)
     store_->AddChannelID(*channel_id);
   const std::string& server_identifier = channel_id->server_identifier();
   channel_ids_[server_identifier] = channel_id.release();
 }
 
 bool DefaultChannelIDStore::IsEphemeral() {
   return !store_;
 }
 
 DefaultChannelIDStore::PersistentStore::PersistentStore() {}
 
 DefaultChannelIDStore::PersistentStore::~PersistentStore() {}
 
 }  // namespace net