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

net/dns/host_cache.cc

 // Copyright (c) 2012 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/dns/host_cache.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 89 matching lines @@
   DCHECK(out);
   out->expired_by = now - expires_;
   out->network_changes = network_changes - network_changes_;
   out->stale_hits = stale_hits_;
 }
 
 HostCache::HostCache(size_t max_entries)
     : max_entries_(max_entries), network_changes_(0) {}
 
 HostCache::~HostCache() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   RecordEraseAll(ERASE_DESTRUCT, base::TimeTicks::Now());
 }
 
 const HostCache::Entry* HostCache::Lookup(const Key& key,
                                           base::TimeTicks now) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (caching_is_disabled())
     return nullptr;
 
   HostCache::Entry* entry = LookupInternal(key);
   if (!entry) {
     RecordLookup(LOOKUP_MISS_ABSENT, now, nullptr);
     return nullptr;
   }
   if (entry->IsStale(now, network_changes_)) {
     RecordLookup(LOOKUP_MISS_STALE, now, entry);
     return nullptr;
   }
 
   entry->CountHit(/* hit_is_stale= */ false);
   RecordLookup(LOOKUP_HIT_VALID, now, entry);
   return entry;
 }
 
 const HostCache::Entry* HostCache::LookupStale(
     const Key& key,
     base::TimeTicks now,
     HostCache::EntryStaleness* stale_out) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (caching_is_disabled())
     return nullptr;
 
   HostCache::Entry* entry = LookupInternal(key);
   if (!entry) {
     RecordLookup(LOOKUP_MISS_ABSENT, now, nullptr);
     return nullptr;
   }
 
   bool is_stale = entry->IsStale(now, network_changes_);
   entry->CountHit(/* hit_is_stale= */ is_stale);
   RecordLookup(is_stale ? LOOKUP_HIT_STALE : LOOKUP_HIT_VALID, now, entry);
 
   if (stale_out)
     entry->GetStaleness(now, network_changes_, stale_out);
   return entry;
 }
 
 HostCache::Entry* HostCache::LookupInternal(const Key& key) {
   auto it = entries_.find(key);
   return (it != entries_.end()) ? &it->second : nullptr;
 }
 
 void HostCache::Set(const Key& key,
                     const Entry& entry,
                     base::TimeTicks now,
                     base::TimeDelta ttl) {
   TRACE_EVENT0(kNetTracingCategory, "HostCache::Set");
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (caching_is_disabled())
     return;
 
   auto it = entries_.find(key);
   if (it != entries_.end()) {
     bool is_stale = it->second.IsStale(now, network_changes_);
     RecordSet(is_stale ? SET_UPDATE_STALE : SET_UPDATE_VALID, now, &it->second,
               entry);
     // TODO(juliatuttle): Remember some old metadata (hit count or frequency or
     // something like that) if it's useful for better eviction algorithms?
     entries_.erase(it);
   } else {
     if (size() == max_entries_)
       EvictOneEntry(now);
     RecordSet(SET_INSERT, now, nullptr, entry);
   }
 
   DCHECK_GT(max_entries_, size());
   DCHECK_EQ(0u, entries_.count(key));
   entries_.insert(
       std::make_pair(Key(key), Entry(entry, now, ttl, network_changes_)));
   DCHECK_GE(max_entries_, size());
 }
 
 void HostCache::OnNetworkChange() {
   ++network_changes_;
 }
 
 void HostCache::clear() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   RecordEraseAll(ERASE_CLEAR, base::TimeTicks::Now());
   entries_.clear();
 }
 
 void HostCache::ClearForHosts(
     const base::Callback<bool(const std::string&)>& host_filter) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (host_filter.is_null()) {
     clear();
     return;
   }
 
   base::TimeTicks now = base::TimeTicks::Now();
   for (EntryMap::iterator it = entries_.begin(); it != entries_.end();) {
     EntryMap::iterator next_it = std::next(it);
 
     if (host_filter.Run(it->first.hostname)) {
       RecordErase(ERASE_CLEAR, now, it->second);
       entries_.erase(it);
     }
 
     it = next_it;
   }
 }
 
 size_t HostCache::size() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return entries_.size();
 }
 
 size_t HostCache::max_entries() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return max_entries_;
 }
 
 // static
 std::unique_ptr<HostCache> HostCache::CreateDefaultCache() {
 // Cache capacity is determined by the field trial.
 #if defined(ENABLE_BUILT_IN_DNS)
   const size_t kDefaultMaxEntries = 1000;
 #else
   const size_t kDefaultMaxEntries = 100;
@@ skipping 120 matching lines @@
     CACHE_HISTOGRAM_TIME("EraseValid.ValidFor", -stale.expired_by);
   }
 }
 
 void HostCache::RecordEraseAll(EraseReason reason, base::TimeTicks now) {
   for (const auto& it : entries_)
     RecordErase(reason, now, it.second);
 }
 
 }  // namespace net