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

net/url_request/sdch_dictionary_fetcher.cc

 // Copyright 2014 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/url_request/sdch_dictionary_fetcher.h"
 
 #include <stdint.h>
 #include <queue>
 #include <set>
 
@@ skipping 98 matching lines @@
   ever_network_queued_.clear();
   while (!queue_.empty())
     queue_.pop();
 }
 
 SdchDictionaryFetcher::SdchDictionaryFetcher(URLRequestContext* context)
     : next_state_(STATE_NONE),
       in_loop_(false),
       fetch_queue_(new UniqueFetchQueue()),
       context_(context) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(context);
 }
 
 SdchDictionaryFetcher::~SdchDictionaryFetcher() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 bool SdchDictionaryFetcher::Schedule(
     const GURL& dictionary_url,
     const OnDictionaryFetchedCallback& callback) {
   return ScheduleInternal(dictionary_url, false, callback);
 }
 
 bool SdchDictionaryFetcher::ScheduleReload(
     const GURL& dictionary_url,
     const OnDictionaryFetchedCallback& callback) {
   return ScheduleInternal(dictionary_url, true, callback);
 }
 
 void SdchDictionaryFetcher::Cancel() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   ResetRequest();
   next_state_ = STATE_NONE;
 
   fetch_queue_->Clear();
 }
 
 void SdchDictionaryFetcher::OnReceivedRedirect(
     URLRequest* request,
     const RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK_EQ(next_state_, STATE_SEND_REQUEST_PENDING);
 
   next_state_ = STATE_RECEIVED_REDIRECT;
 
   DoLoop(OK);
 }
 
 void SdchDictionaryFetcher::OnResponseStarted(URLRequest* request,
                                               int net_error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(request, current_request_.get());
   DCHECK_EQ(next_state_, STATE_SEND_REQUEST_PENDING);
   DCHECK(!in_loop_);
   DCHECK_NE(ERR_IO_PENDING, net_error);
 
   // Confirm that the response isn't a stale read from the cache (as
   // may happen in the reload case).  If the response was not retrieved over
   // HTTP, it is presumed to be fresh.
   HttpResponseHeaders* response_headers = request->response_headers();
   if (net_error == OK && response_headers) {
     bool requires_validation = response_headers->RequiresValidation(
         request->response_info().request_time,
         request->response_info().response_time, base::Time::Now());
     if (requires_validation)
       net_error = ERR_FAILED;
   }
 
   DoLoop(net_error);
 }
 
 void SdchDictionaryFetcher::OnReadCompleted(URLRequest* request,
                                             int bytes_read) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(request, current_request_.get());
   DCHECK_EQ(next_state_, STATE_READ_BODY_COMPLETE);
   DCHECK(!in_loop_);
   DCHECK_NE(ERR_IO_PENDING, bytes_read);
 
   DoLoop(GetReadResult(bytes_read, current_request_.get()));
 }
 
 bool SdchDictionaryFetcher::ScheduleInternal(
     const GURL& dictionary_url,
     bool reload,
     const OnDictionaryFetchedCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If Push() fails, |dictionary_url| has already been fetched or scheduled to
   // be fetched.
   if (!fetch_queue_->Push(FetchInfo(dictionary_url, reload, callback))) {
     // TODO(rdsmith): Log this error to the net log.  In the case of a
     // normal fetch, this can be through the URLRequest
     // initiating this fetch (once the URLRequest is passed to the fetcher);
     // in the case of a reload, it's more complicated.
     SdchManager::SdchErrorRecovery(
         SDCH_DICTIONARY_PREVIOUSLY_SCHEDULED_TO_DOWNLOAD);
@@ skipping 50 matching lines @@
         break;
       case STATE_NONE:
         NOTREACHED();
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
 int SdchDictionaryFetcher::DoSendRequest(int rv) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // |rv| is ignored, as the result from the previous request doesn't
   // affect the next request.
 
   if (fetch_queue_->IsEmpty() || current_request_.get()) {
     next_state_ = STATE_NONE;
     return OK;
   }
 
   next_state_ = STATE_SEND_REQUEST_PENDING;
@@ skipping 51 matching lines @@
 int SdchDictionaryFetcher::DoReceivedRedirect(int rv) {
   // Fetching SDCH through a redirect is forbidden; it raises possible
   // security issues cross-origin, and isn't obviously useful within
   // an origin.
   ResetRequest();
   next_state_ = STATE_SEND_REQUEST;
   return ERR_UNSAFE_REDIRECT;
 }
 
 int SdchDictionaryFetcher::DoSendRequestPending(int rv) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If there's been an error, abort the current request.
   if (rv != OK) {
     ResetRequest();
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
   next_state_ = STATE_READ_BODY;
   return OK;
 }
 
 int SdchDictionaryFetcher::DoReadBody(int rv) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If there's been an error, abort the current request.
   if (rv != OK) {
     ResetRequest();
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
   next_state_ = STATE_READ_BODY_COMPLETE;
   int bytes_read = current_request_->Read(buffer_.get(), kBufferSize);
   if (bytes_read == ERR_IO_PENDING)
     return ERR_IO_PENDING;
 
   return GetReadResult(bytes_read, current_request_.get());
 }
 
 int SdchDictionaryFetcher::DoReadBodyComplete(int rv) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // An error; abort the current request.
   if (rv < 0) {
     ResetRequest();
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
   DCHECK_GE(rv, 0);
 
   // Data; append to the dictionary and look for more data.
   if (rv > 0) {
     dictionary_->append(buffer_->data(), rv);
     next_state_ = STATE_READ_BODY;
     return OK;
   }
 
   // End of file; complete the request.
   next_state_ = STATE_REQUEST_COMPLETE;
   return OK;
 }
 
 int SdchDictionaryFetcher::DoCompleteRequest(int rv) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If the dictionary was successfully fetched, add it to the manager.
   if (rv == OK) {
     current_callback_.Run(*dictionary_, current_request_->url(),
                           current_request_->net_log(),
                           current_request_->was_cached());
   }
 
   ResetRequest();
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
 }  // namespace net