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

net/proxy/dhcp_proxy_script_adapter_fetcher_win.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/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
     URLRequestContext* url_request_context,
     scoped_refptr<base::TaskRunner> task_runner)
     : task_runner_(task_runner),
       state_(STATE_START),
       result_(ERR_IO_PENDING),
       url_request_context_(url_request_context) {
   DCHECK(url_request_context_);
 }
 
 DhcpProxyScriptAdapterFetcher::~DhcpProxyScriptAdapterFetcher() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Cancel();
 }
 
 void DhcpProxyScriptAdapterFetcher::Fetch(
     const std::string& adapter_name, const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(state_, STATE_START);
   result_ = ERR_IO_PENDING;
   pac_script_ = base::string16();
   state_ = STATE_WAIT_DHCP;
   callback_ = callback;
 
   wait_timer_.Start(FROM_HERE, ImplGetTimeout(),
                     this, &DhcpProxyScriptAdapterFetcher::OnTimeout);
   scoped_refptr<DhcpQuery> dhcp_query(ImplCreateDhcpQuery());
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           &DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
           dhcp_query.get(),
           adapter_name),
       base::Bind(
           &DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
           AsWeakPtr(),
           dhcp_query));
 }
 
 void DhcpProxyScriptAdapterFetcher::Cancel() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   callback_.Reset();
   wait_timer_.Stop();
   script_fetcher_.reset();
 
   switch (state_) {
     case STATE_WAIT_DHCP:
       // Nothing to do here, we let the worker thread run to completion,
       // the task it posts back when it completes will check the state.
       break;
     case STATE_WAIT_URL:
       break;
     case STATE_START:
     case STATE_FINISH:
     case STATE_CANCEL:
       break;
   }
 
   if (state_ != STATE_FINISH) {
     result_ = ERR_ABORTED;
     state_ = STATE_CANCEL;
   }
 }
 
 bool DhcpProxyScriptAdapterFetcher::DidFinish() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return state_ == STATE_FINISH;
 }
 
 int DhcpProxyScriptAdapterFetcher::GetResult() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return result_;
 }
 
 base::string16 DhcpProxyScriptAdapterFetcher::GetPacScript() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return pac_script_;
 }
 
 GURL DhcpProxyScriptAdapterFetcher::GetPacURL() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return pac_url_;
 }
 
 DhcpProxyScriptAdapterFetcher::DhcpQuery::DhcpQuery() {
 }
 
 void DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter(
     const std::string& adapter_name) {
   url_ = ImplGetPacURLFromDhcp(adapter_name);
 }
 
 const std::string& DhcpProxyScriptAdapterFetcher::DhcpQuery::url() const {
   return url_;
 }
 
 std::string
     DhcpProxyScriptAdapterFetcher::DhcpQuery::ImplGetPacURLFromDhcp(
         const std::string& adapter_name) {
   return DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
 }
 
 DhcpProxyScriptAdapterFetcher::DhcpQuery::~DhcpQuery() {
 }
 
 void DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone(
     scoped_refptr<DhcpQuery> dhcp_query) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Because we can't cancel the call to the Win32 API, we can expect
   // it to finish while we are in a few different states.  The expected
   // one is WAIT_DHCP, but it could be in CANCEL if Cancel() was called,
   // or FINISH if timeout occurred.
   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_CANCEL ||
          state_ == STATE_FINISH);
   if (state_ != STATE_WAIT_DHCP)
     return;
 
   wait_timer_.Stop();
@@ skipping 12 matching lines @@
   }
 }
 
 void DhcpProxyScriptAdapterFetcher::OnTimeout() {
   DCHECK_EQ(state_, STATE_WAIT_DHCP);
   result_ = ERR_TIMED_OUT;
   TransitionToFinish();
 }
 
 void DhcpProxyScriptAdapterFetcher::OnFetcherDone(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(state_ == STATE_WAIT_URL || state_ == STATE_CANCEL);
   if (state_ == STATE_CANCEL)
     return;
 
   // At this point, pac_script_ has already been written to.
   script_fetcher_.reset();
   result_ = result;
   TransitionToFinish();
 }
 
@@ skipping 99 matching lines @@
   // first null in case of embedded NULLs; this is the outer
   // constructor that takes the result of c_str() on the inner.  If
   // the server is giving us back a buffer with embedded NULLs,
   // something is broken anyway.  Finally, trim trailing whitespace.
   std::string result(std::string(data, count_bytes).c_str());
   base::TrimWhitespaceASCII(result, base::TRIM_TRAILING, &result);
   return result;
 }
 
 }  // namespace net