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

net/ssl/channel_id_service.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/channel_id_service.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 243 matching lines @@
 ChannelIDService::ChannelIDService(ChannelIDStore* channel_id_store)
     : channel_id_store_(channel_id_store),
       id_(g_next_id.GetNext()),
       requests_(0),
       key_store_hits_(0),
       inflight_joins_(0),
       workers_created_(0),
       weak_ptr_factory_(this) {}
 
 ChannelIDService::~ChannelIDService() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 // static
 std::string ChannelIDService::GetDomainForHost(const std::string& host) {
   std::string domain =
       registry_controlled_domains::GetDomainAndRegistry(
           host, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   if (domain.empty())
     return host;
   return domain;
 }
 
 int ChannelIDService::GetOrCreateChannelID(
     const std::string& host,
     std::unique_ptr<crypto::ECPrivateKey>* key,
     const CompletionCallback& callback,
     Request* out_req) {
   DVLOG(1) << __func__ << " " << host;
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (callback.is_null() || !key || host.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   std::string domain = GetDomainForHost(host);
   if (domain.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
@@ skipping 28 matching lines @@
   }
 
   return err;
 }
 
 int ChannelIDService::GetChannelID(const std::string& host,
                                    std::unique_ptr<crypto::ECPrivateKey>* key,
                                    const CompletionCallback& callback,
                                    Request* out_req) {
   DVLOG(1) << __func__ << " " << host;
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (callback.is_null() || !key || host.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   std::string domain = GetDomainForHost(host);
   if (domain.empty()) {
     RecordGetChannelIDResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   requests_++;
 
   // See if a request for the same domain currently in flight.
   bool create_if_missing = false;
   if (JoinToInFlightRequest(domain, key, create_if_missing, callback,
                             out_req)) {
     return ERR_IO_PENDING;
   }
 
   int err = LookupChannelID(domain, key, create_if_missing, callback, out_req);
   return err;
 }
 
 void ChannelIDService::GotChannelID(int err,
                                     const std::string& server_identifier,
                                     std::unique_ptr<crypto::ECPrivateKey> key) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
 
   if (err == OK) {
     // Async DB lookup found a valid channel ID.
     key_store_hits_++;
@@ skipping 19 matching lines @@
 }
 
 ChannelIDStore* ChannelIDService::GetChannelIDStore() {
   return channel_id_store_.get();
 }
 
 void ChannelIDService::GeneratedChannelID(
     const std::string& server_identifier,
     int error,
     std::unique_ptr<ChannelIDStore::ChannelID> channel_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   std::unique_ptr<crypto::ECPrivateKey> key;
   if (error == OK) {
     key = channel_id->key()->Copy();
     channel_id_store_->SetChannelID(std::move(channel_id));
   }
   HandleResult(error, server_identifier, std::move(key));
 }
 
 void ChannelIDService::HandleResult(int error,
                                     const std::string& server_identifier,
                                     std::unique_ptr<crypto::ECPrivateKey> key) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   auto j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   std::unique_ptr<ChannelIDServiceJob> job = std::move(j->second);
   inflight_.erase(j);
 
   job->HandleResult(error, std::move(key));
@@ skipping 51 matching lines @@
   }
 
   return err;
 }
 
 int ChannelIDService::channel_id_count() {
   return channel_id_store_->GetChannelIDCount();
 }
 
 }  // namespace net