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

net/proxy/multi_threaded_proxy_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/proxy/multi_threaded_proxy_resolver.h"
 
 #include <deque>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_checker.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver.h"
 
 namespace net {
@@ skipping 61 matching lines @@
   std::unique_ptr<ProxyResolver> resolver_;
 
   // The thread where |resolver_| is run on.
   // Note that declaration ordering is important here. |thread_| needs to be
   // destroyed *before* |resolver_|, in case |resolver_| is currently
   // executing on |thread_|.
   std::unique_ptr<base::Thread> thread_;
 };
 
 class MultiThreadedProxyResolver : public ProxyResolver,
-                                   public Executor::Coordinator,
-                                   public base::NonThreadSafe {
+                                   public Executor::Coordinator {
  public:
   // Creates an asynchronous ProxyResolver that runs requests on up to
   // |max_num_threads|.
   //
   // For each thread that is created, an accompanying synchronous ProxyResolver
   // will be provisioned using |resolver_factory|. All methods on these
   // ProxyResolvers will be called on the one thread.
   MultiThreadedProxyResolver(
       std::unique_ptr<ProxyResolverFactory> resolver_factory,
       size_t max_num_threads,
@@ skipping 25 matching lines @@
   void AddNewExecutor();
 
   // Starts the next job from |pending_jobs_| if possible.
   void OnExecutorReady(Executor* executor) override;
 
   const std::unique_ptr<ProxyResolverFactory> resolver_factory_;
   const size_t max_num_threads_;
   PendingJobsQueue pending_jobs_;
   ExecutorList executors_;
   scoped_refptr<ProxyResolverScriptData> script_data_;
+
+  THREAD_CHECKER(thread_checker_);
 };
 
 // Job ---------------------------------------------
 
 class Job : public base::RefCountedThreadSafe<Job> {
  public:
   // Identifies the subclass of Job (only being used for debugging purposes).
   enum Type {
     TYPE_GET_PROXY_FOR_URL,
     TYPE_CREATE_RESOLVER,
@@ skipping 282 matching lines @@
     scoped_refptr<Executor> executor)
     : resolver_factory_(std::move(resolver_factory)),
       max_num_threads_(max_num_threads),
       script_data_(script_data) {
   DCHECK(script_data_);
   executor->set_coordinator(this);
   executors_.push_back(executor);
 }
 
 MultiThreadedProxyResolver::~MultiThreadedProxyResolver() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // We will cancel all outstanding requests.
   pending_jobs_.clear();
 
   for (auto& executor : executors_) {
     executor->Destroy();
   }
 }
 
 int MultiThreadedProxyResolver::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
     std::unique_ptr<Request>* request,
     const NetLogWithSource& net_log) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!callback.is_null());
 
   scoped_refptr<GetProxyForURLJob> job(
       new GetProxyForURLJob(url, results, callback, net_log));
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
   if (request)
     request->reset(new RequestImpl(job));
 
@@ skipping 12 matching lines @@
 
   // If we haven't already reached the thread limit, provision a new thread to
   // drain the requests more quickly.
   if (executors_.size() < max_num_threads_)
     AddNewExecutor();
 
   return ERR_IO_PENDING;
 }
 
 Executor* MultiThreadedProxyResolver::FindIdleExecutor() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   for (ExecutorList::iterator it = executors_.begin();
        it != executors_.end(); ++it) {
     Executor* executor = it->get();
     if (!executor->outstanding_job())
       return executor;
   }
   return NULL;
 }
 
 void MultiThreadedProxyResolver::AddNewExecutor() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK_LT(executors_.size(), max_num_threads_);
   // The "thread number" is used to give the thread a unique name.
   int thread_number = executors_.size();
   Executor* executor = new Executor(this, thread_number);
   executor->StartJob(
       new CreateResolverJob(script_data_, resolver_factory_.get()));
   executors_.push_back(make_scoped_refptr(executor));
 }
 
 void MultiThreadedProxyResolver::OnExecutorReady(Executor* executor) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   while (!pending_jobs_.empty()) {
     scoped_refptr<Job> job = pending_jobs_.front();
     pending_jobs_.pop_front();
     if (!job->was_cancelled()) {
       executor->StartJob(job.get());
       return;
     }
   }
 }
 
@@ skipping 85 matching lines @@
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolverFactory::RemoveJob(
     MultiThreadedProxyResolverFactory::Job* job) {
   size_t erased = jobs_.erase(job);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace net