Deprecate NonThreadSafe in components/invalidation in favor of SequenceChecker.

components/invalidation/impl/gcm_invalidation_bridge.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 "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 17 matching lines @@
 const char kInvalidationsAppId[] = "com.google.chrome.invalidations";
 
 // Cacheinvalidation specific gcm message keys.
 const char kContentKey[] = "content";
 const char kEchoTokenKey[] = "echo-token";
 }  // namespace
 
 // Core should be very simple class that implements GCMNetwrokChannelDelegate
 // and passes all calls to GCMInvalidationBridge. All calls should be serialized
 // through GCMInvalidationBridge to avoid race conditions.
-class GCMInvalidationBridge::Core : public syncer::GCMNetworkChannelDelegate,
-                                    public base::NonThreadSafe {
+class GCMInvalidationBridge::Core : public syncer::GCMNetworkChannelDelegate {
  public:
   Core(base::WeakPtr<GCMInvalidationBridge> bridge,
        scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner);
   ~Core() override;
 
   // syncer::GCMNetworkChannelDelegate implementation.
   void Initialize(ConnectionStateCallback connection_state_callback,
                   base::Closure store_reset_callback) override;
   void RequestToken(RequestTokenCallback callback) override;
   void InvalidateToken(const std::string& token) override;
@@ skipping 15 matching lines @@
   void OnStoreReset();
 
  private:
   base::WeakPtr<GCMInvalidationBridge> bridge_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   MessageCallback message_callback_;
   ConnectionStateCallback connection_state_callback_;
   base::Closure store_reset_callback_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 GCMInvalidationBridge::Core::Core(
     base::WeakPtr<GCMInvalidationBridge> bridge,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
     : bridge_(bridge),
       ui_thread_task_runner_(ui_thread_task_runner),
       weak_factory_(this) {
   // Core is created on UI thread but all calls happen on IO thread.
-  DetachFromThread();
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
 GCMInvalidationBridge::Core::~Core() {}
 
 void GCMInvalidationBridge::Core::Initialize(
     ConnectionStateCallback connection_state_callback,
     base::Closure store_reset_callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   connection_state_callback_ = connection_state_callback;
   store_reset_callback_ = store_reset_callback;
   // Pass core WeapPtr and TaskRunner to GCMInvalidationBridge for it to be able
   // to post back.
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::CoreInitializationDone,
                  bridge_,
                  weak_factory_.GetWeakPtr(),
                  base::ThreadTaskRunnerHandle::Get()));
 }
 
 void GCMInvalidationBridge::Core::RequestToken(RequestTokenCallback callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::RequestToken, bridge_, callback));
 }
 
 void GCMInvalidationBridge::Core::InvalidateToken(const std::string& token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::InvalidateToken, bridge_, token));
 }
 
 void GCMInvalidationBridge::Core::Register(RegisterCallback callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Register, bridge_, callback));
 }
 
 void GCMInvalidationBridge::Core::SetMessageReceiver(MessageCallback callback) {
   message_callback_ = callback;
   ui_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::SubscribeForIncomingMessages,
                  bridge_));
 }
 
 void GCMInvalidationBridge::Core::RequestTokenFinished(
     RequestTokenCallback callback,
     const GoogleServiceAuthError& error,
     const std::string& token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   callback.Run(error, token);
 }
 
 void GCMInvalidationBridge::Core::RegisterFinished(
     RegisterCallback callback,
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   callback.Run(registration_id, result);
 }
 
 void GCMInvalidationBridge::Core::OnIncomingMessage(
     const std::string& message,
     const std::string& echo_token) {
   DCHECK(!message_callback_.is_null());
   message_callback_.Run(message, echo_token);
 }
 
@@ skipping 12 matching lines @@
 GCMInvalidationBridge::GCMInvalidationBridge(
     gcm::GCMDriver* gcm_driver,
     IdentityProvider* identity_provider)
     : OAuth2TokenService::Consumer("gcm_network_channel"),
       gcm_driver_(gcm_driver),
       identity_provider_(identity_provider),
       subscribed_for_incoming_messages_(false),
       weak_factory_(this) {}
 
 GCMInvalidationBridge::~GCMInvalidationBridge() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (subscribed_for_incoming_messages_) {
     gcm_driver_->RemoveAppHandler(kInvalidationsAppId);
     gcm_driver_->RemoveConnectionObserver(this);
   }
 }
 
 std::unique_ptr<syncer::GCMNetworkChannelDelegate>
 GCMInvalidationBridge::CreateDelegate() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return base::MakeUnique<Core>(weak_factory_.GetWeakPtr(),
                                 base::ThreadTaskRunnerHandle::Get());
 }
 
 void GCMInvalidationBridge::CoreInitializationDone(
     base::WeakPtr<Core> core,
     scoped_refptr<base::SingleThreadTaskRunner> core_thread_task_runner) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   core_ = core;
   core_thread_task_runner_ = core_thread_task_runner;
 }
 
 void GCMInvalidationBridge::RequestToken(
     syncer::GCMNetworkChannelDelegate::RequestTokenCallback callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (access_token_request_ != NULL) {
     // Report previous request as cancelled.
     GoogleServiceAuthError error(GoogleServiceAuthError::REQUEST_CANCELED);
     std::string access_token;
     core_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
                    core_,
                    request_token_callback_,
                    error,
                    access_token));
   }
   request_token_callback_ = callback;
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   access_token_request_ = identity_provider_->GetTokenService()->StartRequest(
       identity_provider_->GetActiveAccountId(), scopes, this);
 }
 
 void GCMInvalidationBridge::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(access_token_request_.get(), request);
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
                  core_,
                  request_token_callback_,
                  GoogleServiceAuthError::AuthErrorNone(),
                  access_token));
   request_token_callback_.Reset();
   access_token_request_.reset();
 }
 
 void GCMInvalidationBridge::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(access_token_request_.get(), request);
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
                  core_,
                  request_token_callback_,
                  error,
                  std::string()));
   request_token_callback_.Reset();
   access_token_request_.reset();
 }
 
 void GCMInvalidationBridge::InvalidateToken(const std::string& token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   identity_provider_->GetTokenService()->InvalidateAccessToken(
       identity_provider_->GetActiveAccountId(), scopes, token);
 }
 
 void GCMInvalidationBridge::Register(
     syncer::GCMNetworkChannelDelegate::RegisterCallback callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // No-op if GCMClient is disabled.
   if (gcm_driver_ == NULL)
     return;
 
   std::vector<std::string> sender_ids;
   sender_ids.push_back(kInvalidationsSenderId);
   gcm_driver_->Register(kInvalidationsAppId,
                          sender_ids,
                          base::Bind(&GCMInvalidationBridge::RegisterFinished,
                                     weak_factory_.GetWeakPtr(),
                                     callback));
 }
 
 void GCMInvalidationBridge::RegisterFinished(
     syncer::GCMNetworkChannelDelegate::RegisterCallback callback,
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RegisterFinished,
                  core_,
                  callback,
                  registration_id,
                  result));
 }
 
 void GCMInvalidationBridge::Unregister() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // No-op if GCMClient is disabled.
   if (gcm_driver_ == NULL)
     return;
 
   gcm_driver_->Unregister(
       kInvalidationsAppId,
       base::Bind(&GCMInvalidationBridge::UnregisterFinishedNoOp));
 }
 
 // static
@@ skipping 77 matching lines @@
 
 void GCMInvalidationBridge::OnDisconnected() {
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::OnConnectionStateChanged,
                  core_,
                  false));
 }
 
 }  // namespace invalidation