Deprecate NonThreadSafe in components/invalidation in favor of SequenceChecker.

components/invalidation/impl/gcm_network_channel.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 "components/invalidation/impl/gcm_network_channel.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 113 matching lines @@
       weak_factory_(this) {
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
   delegate_->Initialize(
       base::Bind(&GCMNetworkChannel::OnConnectionStateChanged,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&GCMNetworkChannel::OnStoreReset, weak_factory_.GetWeakPtr()));
   Register();
 }
 
 GCMNetworkChannel::~GCMNetworkChannel() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void GCMNetworkChannel::Register() {
   delegate_->Register(base::Bind(&GCMNetworkChannel::OnRegisterComplete,
                                  weak_factory_.GetWeakPtr()));
 }
 
 void GCMNetworkChannel::OnRegisterComplete(
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (result == gcm::GCMClient::SUCCESS) {
     DCHECK(!registration_id.empty());
     DVLOG(2) << "Got registration_id";
     register_backoff_entry_->Reset();
     registration_id_ = registration_id;
     if (!cached_message_.empty())
       RequestAccessToken();
   } else {
     DVLOG(2) << "Register failed: " << result;
     // Retry in case of transient error.
@@ skipping 11 matching lines @@
       }
       default:
         break;
     }
   }
   diagnostic_info_.registration_id_ = registration_id_;
   diagnostic_info_.registration_result_ = result;
 }
 
 void GCMNetworkChannel::SendMessage(const std::string& message) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!message.empty());
   DVLOG(2) << "SendMessage";
   diagnostic_info_.sent_messages_count_++;
   if (!cached_message_.empty()) {
     RecordOutgoingMessageStatus(MESSAGE_DISCARDED);
   }
   cached_message_ = message;
 
   if (!registration_id_.empty()) {
     RequestAccessToken();
   }
 }
 
 void GCMNetworkChannel::RequestAccessToken() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   delegate_->RequestToken(base::Bind(&GCMNetworkChannel::OnGetTokenComplete,
                                      weak_factory_.GetWeakPtr()));
 }
 
 void GCMNetworkChannel::OnGetTokenComplete(
     const GoogleServiceAuthError& error,
     const std::string& token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (cached_message_.empty() || registration_id_.empty()) {
     // Nothing to do.
     return;
   }
 
   if (error.state() != GoogleServiceAuthError::NONE) {
     // Requesting access token failed. Persistent errors will be reported by
     // token service. Just drop this request, cacheinvalidations will retry
     // sending message and at that time we'll retry requesting access token.
     DVLOG(1) << "RequestAccessToken failed: " << error.ToString();
@@ skipping 58 matching lines @@
     const std::string echo_header("echo-token: " + echo_token_);
     fetcher_->AddExtraRequestHeader(echo_header);
   }
   fetcher_->SetUploadData("application/x-protobuffer", cached_message_);
   fetcher_->Start();
   // Clear message to prevent accidentally resending it in the future.
   cached_message_.clear();
 }
 
 void GCMNetworkChannel::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(fetcher_.get(), source);
   // Free fetcher at the end of function.
   std::unique_ptr<net::URLFetcher> fetcher = std::move(fetcher_);
 
   net::URLRequestStatus status = fetcher->GetStatus();
   diagnostic_info_.last_post_response_code_ =
       status.is_success() ? source->GetResponseCode() : status.error();
 
   if (status.is_success() &&
       fetcher->GetResponseCode() == net::HTTP_UNAUTHORIZED) {
@@ skipping 194 matching lines @@
     ENUM_CASE(gcm::GCMClient::UNKNOWN_ERROR);
     ENUM_CASE(gcm::GCMClient::INVALID_PARAMETER);
     ENUM_CASE(gcm::GCMClient::ASYNC_OPERATION_PENDING);
     ENUM_CASE(gcm::GCMClient::GCM_DISABLED);
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace syncer