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

net/proxy/proxy_service.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/proxy_service.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 1024 matching lines @@
                             proxy_delegate, net_log);
 }
 
 int ProxyService::ResolveProxyHelper(const GURL& raw_url,
                                      const std::string& method,
                                      ProxyInfo* result,
                                      const CompletionCallback& callback,
                                      PacRequest** pac_request,
                                      ProxyDelegate* proxy_delegate,
                                      const NetLogWithSource& net_log) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   net_log.BeginEvent(NetLogEventType::PROXY_SERVICE);
 
   // Notify our polling-based dependencies that a resolve is taking place.
   // This way they can schedule their polls in response to network activity.
   config_service_->OnLazyPoll();
   if (script_poller_.get())
      script_poller_->OnLazyPoll();
 
   if (current_state_ == STATE_NONE)
@@ skipping 74 matching lines @@
 
   // Use the manual proxy settings.
   config_.proxy_rules().Apply(url, result);
   result->config_source_ = config_.source();
   result->config_id_ = config_.id();
 
   return OK;
 }
 
 ProxyService::~ProxyService() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
   NetworkChangeNotifier::RemoveDNSObserver(this);
   config_service_->RemoveObserver(this);
 
   // Cancel any inprogress requests.
   for (PendingRequests::iterator it = pending_requests_.begin();
        it != pending_requests_.end();
        ++it) {
     (*it)->Cancel();
   }
@@ skipping 115 matching lines @@
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             const std::string& method,
                                             int net_error,
                                             ProxyInfo* result,
                                             const CompletionCallback& callback,
                                             PacRequest** pac_request,
                                             ProxyDelegate* proxy_delegate,
                                             const NetLogWithSource& net_log) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Check to see if we have a new config since ResolveProxy was called.  We
   // want to re-run ResolveProxy in two cases: 1) we have a new config, or 2) a
   // direct connection failed and we never tried the current config.
 
   DCHECK(result);
   bool re_resolve = result->config_id_ != config_.id();
 
   if (re_resolve) {
     // If we have a new config or the config was never tried, we delete the
@@ skipping 21 matching lines @@
     const std::vector<ProxyServer>& additional_bad_proxies,
     const NetLogWithSource& net_log) {
   result.proxy_list_.UpdateRetryInfoOnFallback(&proxy_retry_info_, retry_delay,
                                                false, additional_bad_proxies,
                                                OK, net_log);
   return result.proxy_list_.size() > (additional_bad_proxies.size() + 1);
 }
 
 void ProxyService::ReportSuccess(const ProxyInfo& result,
                                  ProxyDelegate* proxy_delegate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const ProxyRetryInfoMap& new_retry_info = result.proxy_retry_info();
   if (new_retry_info.empty())
     return;
 
   for (ProxyRetryInfoMap::const_iterator iter = new_retry_info.begin();
        iter != new_retry_info.end(); ++iter) {
     ProxyRetryInfoMap::iterator existing = proxy_retry_info_.find(iter->first);
     if (existing == proxy_retry_info_.end()) {
       proxy_retry_info_[iter->first] = iter->second;
       if (proxy_delegate) {
         const ProxyServer& bad_proxy =
             ProxyServer::FromURI(iter->first, ProxyServer::SCHEME_HTTP);
         const ProxyRetryInfo& proxy_retry_info = iter->second;
         proxy_delegate->OnFallback(bad_proxy, proxy_retry_info.net_error);
       }
     }
     else if (existing->second.bad_until < iter->second.bad_until)
       existing->second.bad_until = iter->second.bad_until;
   }
   if (net_log_) {
     net_log_->AddGlobalEntry(
         NetLogEventType::BAD_PROXY_LIST_REPORTED,
         base::Bind(&NetLogBadProxyListCallback, &new_retry_info));
   }
 }
 
 void ProxyService::CancelPacRequest(PacRequest* req) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(req);
   req->Cancel();
   RemovePendingRequest(req);
 }
 
 LoadState ProxyService::GetLoadState(const PacRequest* req) const {
   CHECK(req);
   if (current_state_ == STATE_WAITING_FOR_INIT_PROXY_RESOLVER)
     return init_proxy_resolver_->GetLoadState();
   return req->GetLoadState();
@@ skipping 90 matching lines @@
     }
   }
 
   net_log.EndEvent(NetLogEventType::PROXY_SERVICE);
   return result_code;
 }
 
 void ProxyService::SetProxyScriptFetchers(
     ProxyScriptFetcher* proxy_script_fetcher,
     std::unique_ptr<DhcpProxyScriptFetcher> dhcp_proxy_script_fetcher) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   State previous_state = ResetProxyConfig(false);
   proxy_script_fetcher_.reset(proxy_script_fetcher);
   dhcp_proxy_script_fetcher_ = std::move(dhcp_proxy_script_fetcher);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnShutdown() {
   // Order here does not matter for correctness. |init_proxy_resolver_| is first
   // because shutting it down also cancels its requests using the fetcher.
   if (init_proxy_resolver_)
     init_proxy_resolver_->OnShutdown();
   if (proxy_script_fetcher_)
     proxy_script_fetcher_->OnShutdown();
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->OnShutdown();
 }
 
 ProxyScriptFetcher* ProxyService::GetProxyScriptFetcher() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return proxy_script_fetcher_.get();
 }
 
 ProxyService::State ProxyService::ResetProxyConfig(bool reset_fetched_config) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   State previous_state = current_state_;
 
   permanent_error_ = OK;
   proxy_retry_info_.clear();
   script_poller_.reset();
   init_proxy_resolver_.reset();
   SuspendAllPendingRequests();
   resolver_.reset();
   config_ = ProxyConfig();
   if (reset_fetched_config)
     fetched_config_ = ProxyConfig();
   current_state_ = STATE_NONE;
 
   return previous_state;
 }
 
 void ProxyService::ResetConfigService(
     std::unique_ptr<ProxyConfigService> new_proxy_config_service) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   State previous_state = ResetProxyConfig(true);
 
   // Release the old configuration service.
   if (config_service_.get())
     config_service_->RemoveObserver(this);
 
   // Set the new configuration service.
   config_service_ = std::move(new_proxy_config_service);
   config_service_->AddObserver(this);
 
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::ForceReloadProxyConfig() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ResetProxyConfig(false);
   ApplyProxyConfigIfAvailable();
 }
 
 // static
 std::unique_ptr<ProxyConfigService>
 ProxyService::CreateSystemProxyConfigService(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
 #if defined(OS_WIN)
@@ skipping 143 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net