Convert //chrome/browser/sync_file_system from scoped_ptr to std::unique_ptr

chrome/browser/sync_file_system/drive_backend/metadata_database_index.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 "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 
 #include <tuple>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/logger.h"
@@ skipping 55 matching lines @@
   typename Container::const_iterator found = container.find(key);
   if (found == container.end())
     return typename Container::mapped_type();
   return found->second;
 }
 
 void ReadDatabaseContents(LevelDBWrapper* db, DatabaseContents* contents) {
   DCHECK(db);
   DCHECK(contents);
 
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
   for (itr->SeekToFirst(); itr->Valid(); itr->Next()) {
     std::string key = itr->key().ToString();
     std::string value = itr->value().ToString();
 
     std::string file_id;
     if (RemovePrefix(key, kFileMetadataKeyPrefix, &file_id)) {
-      scoped_ptr<FileMetadata> metadata(new FileMetadata);
+      std::unique_ptr<FileMetadata> metadata(new FileMetadata);
       if (!metadata->ParseFromString(itr->value().ToString())) {
         util::Log(logging::LOG_WARNING, FROM_HERE,
                   "Failed to parse a FileMetadata");
         continue;
       }
 
       contents->file_metadata.push_back(metadata.release());
       continue;
     }
 
     std::string tracker_id_str;
     if (RemovePrefix(key, kFileTrackerKeyPrefix, &tracker_id_str)) {
       int64_t tracker_id = 0;
       if (!base::StringToInt64(tracker_id_str, &tracker_id)) {
         util::Log(logging::LOG_WARNING, FROM_HERE,
                   "Failed to parse TrackerID");
         continue;
       }
 
-      scoped_ptr<FileTracker> tracker(new FileTracker);
+      std::unique_ptr<FileTracker> tracker(new FileTracker);
       if (!tracker->ParseFromString(itr->value().ToString())) {
         util::Log(logging::LOG_WARNING, FROM_HERE,
                   "Failed to parse a Tracker");
         continue;
       }
       contents->file_trackers.push_back(tracker.release());
       continue;
     }
   }
 }
@@ skipping 70 matching lines @@
     } else {
       PutFileMetadataDeletionToDB(metadata->file_id(), db);
     }
   }
   contents->file_metadata = std::move(referred_file_metadata);
 }
 
 }  // namespace
 
 // static
-scoped_ptr<MetadataDatabaseIndex>
-MetadataDatabaseIndex::Create(LevelDBWrapper* db) {
+std::unique_ptr<MetadataDatabaseIndex> MetadataDatabaseIndex::Create(
+    LevelDBWrapper* db) {
   DCHECK(db);
 
-  scoped_ptr<ServiceMetadata> service_metadata = InitializeServiceMetadata(db);
+  std::unique_ptr<ServiceMetadata> service_metadata =
+      InitializeServiceMetadata(db);
   if (!service_metadata)
-    return scoped_ptr<MetadataDatabaseIndex>();
+    return std::unique_ptr<MetadataDatabaseIndex>();
 
   DatabaseContents contents;
   PutVersionToDB(kCurrentDatabaseVersion, db);
   ReadDatabaseContents(db, &contents);
   RemoveUnreachableItemsFromDB(&contents,
                                service_metadata->sync_root_tracker_id(),
                                db);
 
-  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
+  std::unique_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
   index->Initialize(std::move(service_metadata), &contents);
   return index;
 }
 
 // static
-scoped_ptr<MetadataDatabaseIndex>
-MetadataDatabaseIndex::CreateForTesting(DatabaseContents* contents,
-                                        LevelDBWrapper* db) {
-  scoped_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
-  index->Initialize(make_scoped_ptr(new ServiceMetadata), contents);
+std::unique_ptr<MetadataDatabaseIndex> MetadataDatabaseIndex::CreateForTesting(
+    DatabaseContents* contents,
+    LevelDBWrapper* db) {
+  std::unique_ptr<MetadataDatabaseIndex> index(new MetadataDatabaseIndex(db));
+  index->Initialize(base::WrapUnique(new ServiceMetadata), contents);
   return index;
 }
 
 void MetadataDatabaseIndex::Initialize(
-    scoped_ptr<ServiceMetadata> service_metadata,
+    std::unique_ptr<ServiceMetadata> service_metadata,
     DatabaseContents* contents) {
   service_metadata_ = std::move(service_metadata);
 
   for (size_t i = 0; i < contents->file_metadata.size(); ++i)
-    StoreFileMetadata(make_scoped_ptr(contents->file_metadata[i]));
+    StoreFileMetadata(base::WrapUnique(contents->file_metadata[i]));
   contents->file_metadata.weak_clear();
 
   for (size_t i = 0; i < contents->file_trackers.size(); ++i)
-    StoreFileTracker(make_scoped_ptr(contents->file_trackers[i]));
+    StoreFileTracker(base::WrapUnique(contents->file_trackers[i]));
   contents->file_trackers.weak_clear();
 
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.MetadataNumber", metadata_by_id_.size());
   UMA_HISTOGRAM_COUNTS("SyncFileSystem.TrackerNumber", tracker_by_id_.size());
   UMA_HISTOGRAM_COUNTS_100("SyncFileSystem.RegisteredAppNumber",
                            app_root_by_app_id_.size());
 }
 
 MetadataDatabaseIndex::MetadataDatabaseIndex(LevelDBWrapper* db) : db_(db) {}
 MetadataDatabaseIndex::~MetadataDatabaseIndex() {}
@@ skipping 18 matching lines @@
                                            FileTracker* tracker) const {
   FileTracker* identified = tracker_by_id_.get(tracker_id);
   if (!identified)
     return false;
   if (tracker)
     tracker->CopyFrom(*identified);
   return true;
 }
 
 void MetadataDatabaseIndex::StoreFileMetadata(
-    scoped_ptr<FileMetadata> metadata) {
+    std::unique_ptr<FileMetadata> metadata) {
   PutFileMetadataToDB(*metadata.get(), db_);
   if (!metadata) {
     NOTREACHED();
     return;
   }
 
   std::string file_id = metadata->file_id();
   metadata_by_id_.set(file_id, std::move(metadata));
 }
 
 void MetadataDatabaseIndex::StoreFileTracker(
-    scoped_ptr<FileTracker> tracker) {
+    std::unique_ptr<FileTracker> tracker) {
   PutFileTrackerToDB(*tracker.get(), db_);
   if (!tracker) {
     NOTREACHED();
     return;
   }
 
   int64_t tracker_id = tracker->tracker_id();
   FileTracker* old_tracker = tracker_by_id_.get(tracker_id);
 
   if (!old_tracker) {
@@ skipping 459 matching lines @@
 
     DVLOG(3) << "  Remove from dirty_trackers_: " << tracker_id;
     dirty_trackers_.erase(tracker_id);
 
     demoted_dirty_trackers_.erase(tracker_id);
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system