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

net/proxy/proxy_resolver_v8_tracing.cc

 // Copyright (c) 2013 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/proxy_resolver_v8_tracing.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.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 "base/trace_event/trace_event.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/trace_constants.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 265 matching lines @@
   // These are the inputs to DoDnsOperation(). Written on the worker thread,
   // read by the origin thread.
   std::string pending_dns_host_;
   ResolveDnsOperation pending_dns_op_;
 
   // This contains the resolved address list that DoDnsOperation() fills in.
   // Used exclusively on the origin thread.
   AddressList pending_dns_addresses_;
 };
 
-class ProxyResolverV8TracingImpl : public ProxyResolverV8Tracing,
-                                   public base::NonThreadSafe {
+class ProxyResolverV8TracingImpl : public ProxyResolverV8Tracing {
  public:
   ProxyResolverV8TracingImpl(std::unique_ptr<base::Thread> thread,
                              std::unique_ptr<ProxyResolverV8> resolver,
                              std::unique_ptr<Job::Params> job_params);
 
   ~ProxyResolverV8TracingImpl() override;
 
   // ProxyResolverV8Tracing overrides.
   void GetProxyForURL(const GURL& url,
                       ProxyInfo* results,
@@ skipping 14 matching lines @@
  private:
   // The worker thread on which the ProxyResolverV8 will be run.
   std::unique_ptr<base::Thread> thread_;
   std::unique_ptr<ProxyResolverV8> v8_resolver_;
 
   std::unique_ptr<Job::Params> job_params_;
 
   // The number of outstanding (non-cancelled) jobs.
   int num_outstanding_callbacks_;
 
+  THREAD_CHECKER(thread_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8TracingImpl);
 };
 
 Job::Job(const Job::Params* params,
          std::unique_ptr<ProxyResolverV8Tracing::Bindings> bindings)
     : origin_runner_(base::ThreadTaskRunnerHandle::Get()),
       params_(params),
       bindings_(std::move(bindings)),
       event_(base::WaitableEvent::ResetPolicy::MANUAL,
              base::WaitableEvent::InitialState::NOT_SIGNALED),
@@ skipping 584 matching lines @@
     std::unique_ptr<ProxyResolverV8> resolver,
     std::unique_ptr<Job::Params> job_params)
     : thread_(std::move(thread)),
       v8_resolver_(std::move(resolver)),
       job_params_(std::move(job_params)),
       num_outstanding_callbacks_(0) {
   job_params_->num_outstanding_callbacks = &num_outstanding_callbacks_;
 }
 
 ProxyResolverV8TracingImpl::~ProxyResolverV8TracingImpl() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // Note, all requests should have been cancelled.
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   // Join the worker thread. See http://crbug.com/69710.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   thread_.reset();
 }
 
 ProxyResolverV8TracingImpl::RequestImpl::RequestImpl(scoped_refptr<Job> job)
     : job_(std::move(job)) {}
 
 ProxyResolverV8TracingImpl::RequestImpl::~RequestImpl() {
   job_->Cancel();
 }
 
 LoadState ProxyResolverV8TracingImpl::RequestImpl::GetLoadState() {
   return job_->GetLoadState();
 }
 
 void ProxyResolverV8TracingImpl::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
     std::unique_ptr<ProxyResolver::Request>* request,
     std::unique_ptr<Bindings> bindings) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!callback.is_null());
 
   scoped_refptr<Job> job = new Job(job_params_.get(), std::move(bindings));
 
   request->reset(new RequestImpl(job));
 
   job->StartGetProxyForURL(url, results, callback);
 }
 
 
@@ skipping 127 matching lines @@
 
 }  // namespace
 
 // static
 std::unique_ptr<ProxyResolverV8TracingFactory>
 ProxyResolverV8TracingFactory::Create() {
   return base::WrapUnique(new ProxyResolverV8TracingFactoryImpl());
 }
 
 }  // namespace net