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

net/dns/mock_host_resolver.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/mock_host_resolver.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 80 matching lines @@
   RequestInfo info_;
   AddressList* addresses_;
   CompletionCallback callback_;
   MockHostResolverBase* resolver_;
   size_t id_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestImpl);
 };
 
 MockHostResolverBase::~MockHostResolverBase() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(requests_.empty());
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   RequestPriority priority,
                                   AddressList* addresses,
                                   const CompletionCallback& callback,
                                   std::unique_ptr<Request>* request,
                                   const NetLogWithSource& net_log) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(request);
   last_request_priority_ = priority;
   num_resolve_++;
   size_t id = next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   if (rv != ERR_DNS_CACHE_MISS)
     return rv;
 
   // Just like the real resolver, refuse to do anything with invalid hostnames.
   if (!IsValidDNSDomain(info.hostname()))
@@ skipping 14 matching lines @@
         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
   }
 
   return ERR_IO_PENDING;
 }
 
 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
                                            AddressList* addresses,
                                            const NetLogWithSource& net_log) {
   num_resolve_from_cache_++;
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   return rv;
 }
 
 void MockHostResolverBase::DetachRequest(size_t id) {
   RequestMap::iterator it = requests_.find(id);
   CHECK(it != requests_.end());
   requests_.erase(it);
 }
 
 HostCache* MockHostResolverBase::GetHostCache() {
   return cache_.get();
 }
 
 void MockHostResolverBase::ResolveAllPending() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(ondemand_mode_);
   for (RequestMap::iterator i = requests_.begin(); i != requests_.end(); ++i) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
   }
 }
 
 // start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
@@ skipping 307 matching lines @@
   CHECK_EQ(old_proc, current_proc_.get());
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
   current_proc_->SetLastProc(previous_proc_.get());
 }
 
 }  // namespace net