Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/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 "sync/internal_api/public/attachments/on_disk_attachment_store.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "sync/internal_api/attachments/proto/attachment_store.pb.h"
 #include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/protocol/attachments.pb.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "third_party/leveldatabase/src/include/leveldb/slice.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
@@ skipping 140 matching lines @@
   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());
-  scoped_ptr<AttachmentMap> result_map(new AttachmentMap());
-  scoped_ptr<AttachmentIdList> unavailable_attachments(new AttachmentIdList());
+  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) {
-      scoped_ptr<Attachment> attachment;
+      std::unique_ptr<Attachment> attachment;
       attachment = ReadSingleAttachment(id, component);
       if (attachment) {
         result_map->insert(std::make_pair(id, *attachment));
       } else {
         unavailable_attachments->push_back(id);
       }
     }
     result_code = unavailable_attachments->empty()
                       ? AttachmentStore::SUCCESS
                       : AttachmentStore::UNSPECIFIED_ERROR;
@@ skipping 81 matching lines @@
   PostCallback(base::Bind(callback, result_code));
 }
 
 void OnDiskAttachmentStore::ReadMetadataById(
     AttachmentStore::Component component,
     const AttachmentIdList& ids,
     const AttachmentStore::ReadMetadataCallback& callback) {
   DCHECK(CalledOnValidThread());
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
-  scoped_ptr<AttachmentMetadataList> metadata_list(
+  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());
   AttachmentStore::Result result_code =
       AttachmentStore::STORE_INITIALIZATION_FAILED;
-  scoped_ptr<AttachmentMetadataList> metadata_list(
+  std::unique_ptr<AttachmentMetadataList> metadata_list(
       new AttachmentMetadataList());
 
   if (db_) {
     attachment_store_pb::RecordMetadata::Component proto_component =
         ComponentToProto(component);
     result_code = AttachmentStore::SUCCESS;
-    scoped_ptr<leveldb::Iterator> db_iterator(
+    std::unique_ptr<leveldb::Iterator> db_iterator(
         db_->NewIterator(MakeNonCachingReadOptions()));
     DCHECK(db_iterator);
     for (db_iterator->Seek(kMetadataPrefix); db_iterator->Valid();
          db_iterator->Next()) {
       leveldb::Slice key = db_iterator->key();
       if (!key.starts_with(kMetadataPrefix)) {
         break;
       }
       // Make AttachmentId from levelDB key.
       key.remove_prefix(strlen(kMetadataPrefix));
@@ skipping 21 matching lines @@
 
   PostCallback(base::Bind(callback, result_code, base::Passed(&metadata_list)));
 }
 
 AttachmentStore::Result OnDiskAttachmentStore::OpenOrCreate(
     const base::FilePath& path) {
   DCHECK(!db_);
   base::FilePath leveldb_path = path.Append(kLeveldbDirectory);
 
   leveldb::DB* db_raw;
-  scoped_ptr<leveldb::DB> db;
+  std::unique_ptr<leveldb::DB> db;
   leveldb::Options options;
   options.create_if_missing = true;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
   // TODO(pavely): crbug/424287 Consider adding info_log, block_cache and
   // filter_policy to options.
   leveldb::Status status =
       leveldb::DB::Open(options, leveldb_path.AsUTF8Unsafe(), &db_raw);
   if (!status.ok()) {
     DVLOG(1) << "DB::Open failed: status=" << status.ToString()
              << ", path=" << path.AsUTF8Unsafe();
@@ skipping 23 matching lines @@
 
   if (metadata.schema_version() != kCurrentSchemaVersion) {
     DVLOG(1) << "Unknown schema version: " << metadata.schema_version();
     return AttachmentStore::UNSPECIFIED_ERROR;
   }
 
   db_ = std::move(db);
   return AttachmentStore::SUCCESS;
 }
 
-scoped_ptr<Attachment> OnDiskAttachmentStore::ReadSingleAttachment(
+std::unique_ptr<Attachment> OnDiskAttachmentStore::ReadSingleAttachment(
     const AttachmentId& attachment_id,
     AttachmentStore::Component component) {
-  scoped_ptr<Attachment> attachment;
+  std::unique_ptr<Attachment> attachment;
   attachment_store_pb::RecordMetadata record_metadata;
   if (!ReadSingleRecordMetadata(attachment_id, &record_metadata)) {
     return attachment;
   }
   if (!AttachmentHasReferenceFromComponent(record_metadata,
                                            ComponentToProto(component)))
     return attachment;
 
   const std::string key = MakeDataKeyFromAttachmentId(attachment_id);
   std::string data_str;
@@ skipping 112 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