Deprecate NonThreadSafe in components/sync in favor of SequenceChecker.

components/sync/engine/attachments/on_disk_attachment_store.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/attachments/on_disk_attachment_store.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 136 matching lines @@
   return false;
 }
 
 }  // namespace
 
 OnDiskAttachmentStore::OnDiskAttachmentStore(
     const scoped_refptr<base::SequencedTaskRunner>& callback_task_runner,
     const base::FilePath& path)
     : AttachmentStoreBackend(callback_task_runner), path_(path) {}
 
-OnDiskAttachmentStore::~OnDiskAttachmentStore() {}
+OnDiskAttachmentStore::~OnDiskAttachmentStore() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 void OnDiskAttachmentStore::Init(
     const AttachmentStore::InitCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AttachmentStore::Result result_code = OpenOrCreate(path_);
   UMA_HISTOGRAM_ENUMERATION("Sync.Attachments.StoreInitResult", result_code,
                             AttachmentStore::RESULT_SIZE);
   PostCallback(base::Bind(callback, result_code));
 }
 
 void OnDiskAttachmentStore::Read(
     AttachmentStore::Component component,
     const AttachmentIdList& ids,
     const AttachmentStore::ReadCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::unique_ptr<AttachmentMap> result_map(new AttachmentMap());
   std::unique_ptr<AttachmentIdList> unavailable_attachments(
       new AttachmentIdList());
 
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
 
   if (db_) {
     result_code = AttachmentStore::SUCCESS;
     for (const auto& id : ids) {
@@ skipping 13 matching lines @@
   }
 
   PostCallback(base::Bind(callback, result_code, base::Passed(&result_map),
                           base::Passed(&unavailable_attachments)));
 }
 
 void OnDiskAttachmentStore::Write(
     AttachmentStore::Component component,
     const AttachmentList& attachments,
     const AttachmentStore::WriteCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
 
   if (db_) {
     result_code = AttachmentStore::SUCCESS;
     AttachmentList::const_iterator iter = attachments.begin();
     const AttachmentList::const_iterator end = attachments.end();
     for (; iter != end; ++iter) {
       if (!WriteSingleAttachment(*iter, component))
         result_code = AttachmentStore::UNSPECIFIED_ERROR;
     }
   }
   PostCallback(base::Bind(callback, result_code));
 }
 
 void OnDiskAttachmentStore::SetReference(AttachmentStore::Component component,
                                          const AttachmentIdList& ids) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!db_)
     return;
   attachment_store_pb::RecordMetadata::Component proto_component =
       ComponentToProto(component);
   for (const auto& id : ids) {
     attachment_store_pb::RecordMetadata record_metadata;
     if (!ReadSingleRecordMetadata(id, &record_metadata))
       continue;
     if (SetReferenceInRecordMetadata(&record_metadata, proto_component))
       WriteSingleRecordMetadata(id, record_metadata);
   }
 }
 
 void OnDiskAttachmentStore::DropReference(
     AttachmentStore::Component component,
     const AttachmentIdList& ids,
     const AttachmentStore::DropCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
   if (db_) {
     attachment_store_pb::RecordMetadata::Component proto_component =
         ComponentToProto(component);
     result_code = AttachmentStore::SUCCESS;
     leveldb::WriteOptions write_options = MakeWriteOptions();
     for (const auto& id : ids) {
       attachment_store_pb::RecordMetadata record_metadata;
       if (!ReadSingleRecordMetadata(id, &record_metadata))
@@ skipping 19 matching lines @@
       }
     }
   }
   PostCallback(base::Bind(callback, result_code));
 }
 
 void OnDiskAttachmentStore::ReadMetadataById(
     AttachmentStore::Component component,
     const AttachmentIdList& ids,
     const AttachmentStore::ReadMetadataCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
   std::unique_ptr<AttachmentMetadataList> metadata_list(
       new AttachmentMetadataList());
   if (db_) {
     result_code = AttachmentStore::SUCCESS;
     for (const auto& id : ids) {
       attachment_store_pb::RecordMetadata record_metadata;
       if (!ReadSingleRecordMetadata(id, &record_metadata)) {
         result_code = AttachmentStore::UNSPECIFIED_ERROR;
         continue;
       }
       if (!AttachmentHasReferenceFromComponent(record_metadata,
                                                ComponentToProto(component))) {
         result_code = AttachmentStore::UNSPECIFIED_ERROR;
         continue;
       }
       metadata_list->push_back(MakeAttachmentMetadata(id, record_metadata));
     }
   }
   PostCallback(base::Bind(callback, result_code, base::Passed(&metadata_list)));
 }
 
 void OnDiskAttachmentStore::ReadMetadata(
     AttachmentStore::Component component,
     const AttachmentStore::ReadMetadataCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
   std::unique_ptr<AttachmentMetadataList> metadata_list(
       new AttachmentMetadataList());
 
   if (db_) {
     attachment_store_pb::RecordMetadata::Component proto_component =
         ComponentToProto(component);
     result_code = AttachmentStore::SUCCESS;
     std::unique_ptr<leveldb::Iterator> db_iterator(
@@ skipping 211 matching lines @@
   return key;
 }
 
 AttachmentMetadata OnDiskAttachmentStore::MakeAttachmentMetadata(
     const AttachmentId& attachment_id,
     const attachment_store_pb::RecordMetadata& record_metadata) {
   return AttachmentMetadata(attachment_id, record_metadata.attachment_size());
 }
 
 }  // namespace syncer