Deprecate NonThreadSafe in components/sync in favor of SequenceChecker.

components/sync/engine_impl/attachments/attachment_uploader_impl.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/sync/engine_impl/attachments/attachment_uploader_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 23 matching lines @@
 const char kContentType[] = "application/octet-stream";
 const char kAttachments[] = "attachments/";
 const char kSyncStoreBirthday[] = "X-Sync-Store-Birthday";
 const char kSyncDataTypeId[] = "X-Sync-Data-Type-Id";
 
 }  // namespace
 
 namespace syncer {
 
 // Encapsulates all the state associated with a single upload.
-class AttachmentUploaderImpl::UploadState : public net::URLFetcherDelegate,
-                                            public OAuth2TokenService::Consumer,
-                                            public base::NonThreadSafe {
+class AttachmentUploaderImpl::UploadState
+    : public net::URLFetcherDelegate,
+      public OAuth2TokenService::Consumer {
  public:
   // Construct an UploadState.
   //
   // UploadState encapsulates the state associated with a single upload.  When
   // the upload completes, the UploadState object becomes "stopped".
   //
   // |owner| is a pointer to the object that owns this UploadState.  Upon
   // completion this object will PostTask to owner's OnUploadStateStopped
   // method.
   UploadState(
@@ skipping 53 matching lines @@
   std::string account_id_;
   OAuth2TokenService::ScopeSet scopes_;
   std::string access_token_;
   std::string raw_store_birthday_;
   OAuth2TokenServiceRequest::TokenServiceProvider* token_service_provider_;
   // Pointer to the AttachmentUploaderImpl that owns this object.
   base::WeakPtr<AttachmentUploaderImpl> owner_;
   std::unique_ptr<OAuth2TokenServiceRequest> access_token_request_;
   ModelType model_type_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(UploadState);
 };
 
 AttachmentUploaderImpl::UploadState::UploadState(
     const GURL& upload_url,
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter,
     const Attachment& attachment,
     const UploadCallback& user_callback,
     const std::string& account_id,
@@ skipping 19 matching lines @@
   DCHECK(!account_id_.empty());
   DCHECK(!scopes_.empty());
   DCHECK(token_service_provider_);
   DCHECK(!raw_store_birthday_.empty());
   GetToken();
 }
 
 AttachmentUploaderImpl::UploadState::~UploadState() {}
 
 bool AttachmentUploaderImpl::UploadState::IsStopped() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return is_stopped_;
 }
 
 void AttachmentUploaderImpl::UploadState::AddUserCallback(
     const UploadCallback& user_callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!is_stopped_);
   user_callbacks_.push_back(user_callback);
 }
 
 const Attachment& AttachmentUploaderImpl::UploadState::GetAttachment() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return attachment_;
 }
 
 void AttachmentUploaderImpl::UploadState::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (is_stopped_) {
     return;
   }
 
   UploadResult result = UPLOAD_TRANSIENT_ERROR;
   AttachmentId attachment_id = attachment_.GetId();
   net::URLRequestStatus status = source->GetStatus();
   const int response_code = source->GetResponseCode();
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "Sync.Attachments.UploadResponseCode",
@@ skipping 12 matching lines @@
   } else if (response_code == net::URLFetcher::RESPONSE_CODE_INVALID) {
     result = UPLOAD_TRANSIENT_ERROR;
   }
   StopAndReportResult(result, attachment_id);
 }
 
 void AttachmentUploaderImpl::UploadState::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (is_stopped_) {
     return;
   }
 
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   access_token_ = access_token;
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("sync_attachment_uploader", R"(
         semantics {
@@ skipping 38 matching lines @@
   scoped_refptr<base::RefCountedMemory> memory = attachment_.GetData();
   const std::string upload_content(memory->front_as<char>(), memory->size());
   fetcher_->SetUploadData(kContentType, upload_content);
 
   fetcher_->Start();
 }
 
 void AttachmentUploaderImpl::UploadState::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (is_stopped_) {
     return;
   }
 
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   // TODO(maniscalco): We treat this as a transient error, but it may in fact be
   // a very long lived error and require user action.  Consider differentiating
   // between the causes of GetToken failure and act accordingly.  Think about
   // the causes of GetToken failure. Are there (bug 412802).
@@ skipping 32 matching lines @@
     const std::string& store_birthday,
     ModelType model_type)
     : sync_service_url_(sync_service_url),
       url_request_context_getter_(url_request_context_getter),
       account_id_(account_id),
       scopes_(scopes),
       token_service_provider_(token_service_provider),
       raw_store_birthday_(store_birthday),
       model_type_(model_type),
       weak_ptr_factory_(this) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!account_id.empty());
   DCHECK(!scopes.empty());
   DCHECK(token_service_provider_.get());
   DCHECK(!raw_store_birthday_.empty());
 }
 
 AttachmentUploaderImpl::~AttachmentUploaderImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void AttachmentUploaderImpl::UploadAttachment(const Attachment& attachment,
                                               const UploadCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const AttachmentId attachment_id = attachment.GetId();
   const std::string unique_id = attachment_id.GetProto().unique_id();
   DCHECK(!unique_id.empty());
   StateMap::iterator iter = state_map_.find(unique_id);
   if (iter != state_map_.end()) {
     // We have an old upload request for this attachment...
     if (!iter->second->IsStopped()) {
       // "join" to it.
       DCHECK(attachment.GetData()->Equals(
           iter->second->GetAttachment().GetData()));
@@ skipping 74 matching lines @@
       "%s: %s", kSyncStoreBirthday, encoded_store_birthday.c_str()));
 
   // Use field number to pass ModelType because it's stable and we have server
   // code to decode it.
   const int field_number = GetSpecificsFieldNumberFromModelType(model_type);
   fetcher->AddExtraRequestHeader(
       base::StringPrintf("%s: %d", kSyncDataTypeId, field_number));
 }
 
 }  // namespace syncer