Convert //components/dom_distiller from scoped_ptr to std::unique_ptr

components/dom_distiller/core/dom_distiller_store.cc

 // Copyright 2013 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/dom_distiller/core/dom_distiller_store.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 21 matching lines @@
 // Statistics are logged to UMA with this string as part of histogram name. They
 // can all be found under LevelDB.*.DomDistillerStore. Changing this needs to
 // synchronize with histograms.xml, AND will also become incompatible with older
 // browsers still reporting the previous values.
 const char kDatabaseUMAClientName[] = "DomDistillerStore";
 }
 
 namespace dom_distiller {
 
 DomDistillerStore::DomDistillerStore(
-    scoped_ptr<ProtoDatabase<ArticleEntry>> database,
+    std::unique_ptr<ProtoDatabase<ArticleEntry>> database,
     const base::FilePath& database_dir)
     : database_(std::move(database)),
       database_loaded_(false),
       attachment_store_(syncer::AttachmentStore::CreateInMemoryStore()),
       weak_ptr_factory_(this) {
   database_->Init(kDatabaseUMAClientName, database_dir,
                   base::Bind(&DomDistillerStore::OnDatabaseInit,
                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 DomDistillerStore::DomDistillerStore(
-    scoped_ptr<ProtoDatabase<ArticleEntry>> database,
+    std::unique_ptr<ProtoDatabase<ArticleEntry>> database,
     const std::vector<ArticleEntry>& initial_data,
     const base::FilePath& database_dir)
     : database_(std::move(database)),
       database_loaded_(false),
       attachment_store_(syncer::AttachmentStore::CreateInMemoryStore()),
       model_(initial_data),
       weak_ptr_factory_(this) {
   database_->Init(kDatabaseUMAClientName, database_dir,
                   base::Bind(&DomDistillerStore::OnDatabaseInit,
                              weak_ptr_factory_.GetWeakPtr()));
@@ skipping 10 matching lines @@
                                      ArticleEntry* entry) {
   return model_.GetEntryById(entry_id, entry);
 }
 
 bool DomDistillerStore::GetEntryByUrl(const GURL& url, ArticleEntry* entry) {
   return model_.GetEntryByUrl(url, entry);
 }
 
 void DomDistillerStore::UpdateAttachments(
     const std::string& entry_id,
-    scoped_ptr<ArticleAttachmentsData> attachments_data,
+    std::unique_ptr<ArticleAttachmentsData> attachments_data,
     const UpdateAttachmentsCallback& callback) {
   if (!GetEntryById(entry_id, nullptr)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, false));
   }
 
-  scoped_ptr<sync_pb::ArticleAttachments> article_attachments(
+  std::unique_ptr<sync_pb::ArticleAttachments> article_attachments(
       new sync_pb::ArticleAttachments());
   syncer::AttachmentList attachment_list;
   attachments_data->CreateSyncAttachments(&attachment_list,
                                           article_attachments.get());
 
   attachment_store_->Write(
       attachment_list,
       base::Bind(&DomDistillerStore::OnAttachmentsWrite,
                  weak_ptr_factory_.GetWeakPtr(), entry_id,
                  base::Passed(&article_attachments), callback));
 }
 
 void DomDistillerStore::OnAttachmentsWrite(
     const std::string& entry_id,
-    scoped_ptr<sync_pb::ArticleAttachments> article_attachments,
+    std::unique_ptr<sync_pb::ArticleAttachments> article_attachments,
     const UpdateAttachmentsCallback& callback,
     const syncer::AttachmentStore::Result& result) {
   bool success = false;
   switch (result) {
     case syncer::AttachmentStore::UNSPECIFIED_ERROR:
     case syncer::AttachmentStore::STORE_INITIALIZATION_FAILED:
       break;
     case syncer::AttachmentStore::SUCCESS:
       success = true;
       break;
@@ skipping 49 matching lines @@
   attachment_store_->Read(GetAttachmentIds(entry.attachments()),
                           base::Bind(&DomDistillerStore::OnAttachmentsRead,
                                      weak_ptr_factory_.GetWeakPtr(),
                                      entry.attachments(), callback));
 }
 
 void DomDistillerStore::OnAttachmentsRead(
     const sync_pb::ArticleAttachments& attachments_proto,
     const GetAttachmentsCallback& callback,
     const syncer::AttachmentStore::Result& result,
-    scoped_ptr<syncer::AttachmentMap> attachments,
-    scoped_ptr<syncer::AttachmentIdList> missing) {
+    std::unique_ptr<syncer::AttachmentMap> attachments,
+    std::unique_ptr<syncer::AttachmentIdList> missing) {
   bool success = false;
   switch (result) {
     case syncer::AttachmentStore::UNSPECIFIED_ERROR:
     case syncer::AttachmentStore::STORE_INITIALIZATION_FAILED:
       break;
     case syncer::AttachmentStore::SUCCESS:
       DCHECK(missing->empty());
       success = true;
       break;
   }
-  scoped_ptr<ArticleAttachmentsData> attachments_data;
+  std::unique_ptr<ArticleAttachmentsData> attachments_data;
   if (success) {
     attachments_data = ArticleAttachmentsData::GetFromAttachmentMap(
         attachments_proto, *attachments);
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, success, base::Passed(&attachments_data)));
 }
 
 bool DomDistillerStore::AddEntry(const ArticleEntry& entry) {
@@ skipping 72 matching lines @@
 void DomDistillerStore::RemoveObserver(DomDistillerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::vector<ArticleEntry> DomDistillerStore::GetEntries() const {
   return model_.GetEntries();
 }
 
 // syncer::SyncableService implementation.
 SyncMergeResult DomDistillerStore::MergeDataAndStartSyncing(
-    ModelType type, const SyncDataList& initial_sync_data,
-    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-    scoped_ptr<syncer::SyncErrorFactory> error_handler) {
+    ModelType type,
+    const SyncDataList& initial_sync_data,
+    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+    std::unique_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK_EQ(syncer::ARTICLES, type);
   DCHECK(!sync_processor_);
   DCHECK(!error_factory_);
   sync_processor_.reset(sync_processor.release());
   error_factory_.reset(error_handler.release());
 
   SyncChangeList database_changes;
   SyncChangeList sync_changes;
   SyncMergeResult result =
       MergeDataWithModel(initial_sync_data, &database_changes, &sync_changes);
@@ skipping 66 matching lines @@
   if (!success) {
     DVLOG(1) << "DOM Distiller database init failed.";
     database_.reset();
     return;
   }
   database_->LoadEntries(base::Bind(&DomDistillerStore::OnDatabaseLoad,
                                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DomDistillerStore::OnDatabaseLoad(bool success,
-                                       scoped_ptr<EntryVector> entries) {
+                                       std::unique_ptr<EntryVector> entries) {
   if (!success) {
     DVLOG(1) << "DOM Distiller database load failed.";
     database_.reset();
     return;
   }
   database_loaded_ = true;
 
   SyncDataList data;
   for (EntryVector::iterator it = entries->begin(); it != entries->end();
        ++it) {
@@ skipping 35 matching lines @@
 }
 
 bool DomDistillerStore::ApplyChangesToDatabase(
     const SyncChangeList& change_list) {
   if (!database_loaded_) {
     return false;
   }
   if (change_list.empty()) {
     return true;
   }
-  scoped_ptr<ProtoDatabase<ArticleEntry>::KeyEntryVector> entries_to_save(
+  std::unique_ptr<ProtoDatabase<ArticleEntry>::KeyEntryVector> entries_to_save(
       new ProtoDatabase<ArticleEntry>::KeyEntryVector());
-  scoped_ptr<std::vector<std::string> > keys_to_remove(
+  std::unique_ptr<std::vector<std::string>> keys_to_remove(
       new std::vector<std::string>());
 
   for (SyncChangeList::const_iterator it = change_list.begin();
        it != change_list.end(); ++it) {
     if (it->change_type() == SyncChange::ACTION_DELETE) {
       ArticleEntry entry = GetEntryFromChange(*it);
       keys_to_remove->push_back(entry.entry_id());
     } else {
       ArticleEntry entry = GetEntryFromChange(*it);
       entries_to_save->push_back(std::make_pair(entry.entry_id(), entry));
@@ skipping 43 matching lines @@
   result.set_num_items_deleted(0);
 
   result.set_pre_association_version(0);
   result.set_num_items_after_association(model_.GetNumEntries());
   result.set_error(error);
 
   return result;
 }
 
 }  // namespace dom_distiller