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

chrome/browser/sync_file_system/drive_backend/metadata_database_index_on_disk.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_on_disk.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
@@ skipping 140 matching lines @@
 
 void RemoveUnreachableItemsFromDB(LevelDBWrapper* db,
                                   int64_t sync_root_tracker_id) {
   DCHECK(db);
 
   typedef std::map<int64_t, std::set<int64_t>> ChildTrackersByParent;
   ChildTrackersByParent trackers_by_parent;
   {
     // Set up links from parent tracker to child trackers.
     std::set<int64_t> inactive_trackers;
-    scoped_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
+    std::unique_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
     for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
       if (!RemovePrefix(itr->key().ToString(), kFileTrackerKeyPrefix, nullptr))
         break;
 
-      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;
       }
 
       int64_t parent_tracker_id = tracker->parent_tracker_id();
       int64_t tracker_id = tracker->tracker_id();
       trackers_by_parent[parent_tracker_id].insert(tracker_id);
       if (!tracker->active())
@@ skipping 27 matching lines @@
       AppendContents(
           LookUpMap(trackers_by_parent, tracker_id, std::set<int64_t>()),
           &pending);
     }
   }
 
   // Delete all unreachable trackers, and list all |file_id| referred by
   // remained trackers.
   base::hash_set<std::string> referred_file_ids;
   {
-    scoped_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
+    std::unique_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
     for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
       if (!RemovePrefix(itr->key().ToString(), kFileTrackerKeyPrefix, nullptr))
         break;
 
-      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;
       }
 
       if (ContainsKey(visited_trackers, tracker->tracker_id())) {
         referred_file_ids.insert(tracker->file_id());
       } else {
         PutFileTrackerDeletionToDB(tracker->tracker_id(), db);
       }
     }
   }
 
   // Delete all unreferred metadata.
   {
-    scoped_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
+    std::unique_ptr<LevelDBWrapper::Iterator> itr = db->NewIterator();
     for (itr->Seek(kFileMetadataKeyPrefix); itr->Valid(); itr->Next()) {
       if (!RemovePrefix(itr->key().ToString(), kFileMetadataKeyPrefix, nullptr))
         break;
 
-      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 Tracker");
         continue;
       }
 
       if (!ContainsKey(referred_file_ids, metadata->file_id()))
         PutFileMetadataDeletionToDB(metadata->file_id(), db);
     }
   }
 }
 
 }  // namespace
 
 // static
-scoped_ptr<MetadataDatabaseIndexOnDisk>
+std::unique_ptr<MetadataDatabaseIndexOnDisk>
 MetadataDatabaseIndexOnDisk::Create(LevelDBWrapper* db) {
   DCHECK(db);
 
-  scoped_ptr<ServiceMetadata> service_metadata = InitializeServiceMetadata(db);
+  std::unique_ptr<ServiceMetadata> service_metadata =
+      InitializeServiceMetadata(db);
   if (!service_metadata)
     return nullptr;
 
   PutVersionToDB(kDatabaseOnDiskVersion, db);
   RemoveUnreachableItemsFromDB(db, service_metadata->sync_root_tracker_id());
-  scoped_ptr<MetadataDatabaseIndexOnDisk>
-      index(new MetadataDatabaseIndexOnDisk(db));
+  std::unique_ptr<MetadataDatabaseIndexOnDisk> index(
+      new MetadataDatabaseIndexOnDisk(db));
 
   return index;
 }
 
 MetadataDatabaseIndexOnDisk::~MetadataDatabaseIndexOnDisk() {}
 
 void MetadataDatabaseIndexOnDisk::RemoveUnreachableItems() {
   RemoveUnreachableItemsFromDB(
       db_, service_metadata_->sync_root_tracker_id());
   DeleteTrackerIndexes();
@@ skipping 55 matching lines @@
               tracker_id);
     return false;
   }
   if (tracker)
     tracker->CopyFrom(tmp_tracker);
 
   return true;
 }
 
 void MetadataDatabaseIndexOnDisk::StoreFileMetadata(
-    scoped_ptr<FileMetadata> metadata) {
+    std::unique_ptr<FileMetadata> metadata) {
   DCHECK(metadata);
   PutFileMetadataToDB(*metadata, db_);
 }
 
 void MetadataDatabaseIndexOnDisk::StoreFileTracker(
-    scoped_ptr<FileTracker> tracker) {
+    std::unique_ptr<FileTracker> tracker) {
   DCHECK(tracker);
 
   int64_t tracker_id = tracker->tracker_id();
   FileTracker old_tracker;
   if (!GetFileTracker(tracker_id, &old_tracker)) {
     DVLOG(3) << "Adding new tracker: " << tracker->tracker_id()
              << " " << GetTrackerTitle(*tracker);
     AddToAppIDIndex(*tracker);
     AddToFileIDIndexes(*tracker);
     AddToPathIndexes(*tracker);
@@ skipping 74 matching lines @@
   return GetTrackerIDSetByPrefix(
       GenerateActiveTrackerIDByParentAndTitleKey(parent_tracker_id, title),
       GenerateTrackerIDByParentAndTitleKeyPrefix(parent_tracker_id, title));
 }
 
 std::vector<int64_t> MetadataDatabaseIndexOnDisk::GetFileTrackerIDsByParent(
     int64_t parent_id) const {
   std::vector<int64_t> result;
 
   const std::string prefix = GenerateTrackerIDsByParentIDKeyPrefix(parent_id);
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
     const std::string& key(itr->key().ToString());
     std::string title_and_id;
     if (!RemovePrefix(key, prefix, &title_and_id))
       break;
 
     size_t pos = title_and_id.rfind('\0');
     DCHECK(pos != std::string::npos);
 
     int64_t tracker_id;
     if (!base::StringToInt64(title_and_id.substr(pos + 1), &tracker_id))
       continue;
     result.push_back(tracker_id);
   }
   return result;
 }
 
 std::string MetadataDatabaseIndexOnDisk::PickMultiTrackerFileID() const {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   itr->Seek(kMultiTrackerByFileIDKeyPrefix);
   if (!itr->Valid())
     return std::string();
 
   std::string file_id;
   if (!RemovePrefix(itr->key().ToString(),
                     kMultiTrackerByFileIDKeyPrefix, &file_id))
     return std::string();
 
   return file_id;
 }
 
 ParentIDAndTitle MetadataDatabaseIndexOnDisk::PickMultiBackingFilePath() const {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   itr->Seek(kMultiBackingParentAndTitleKeyPrefix);
   if (!itr->Valid())
     return ParentIDAndTitle();
 
   std::string value;
   if (!RemovePrefix(itr->key().ToString(),
                     kMultiBackingParentAndTitleKeyPrefix, &value))
     return ParentIDAndTitle();
 
   size_t pos = value.find('\0');  // '\0' is a separator.
   if (pos == std::string::npos)
     return ParentIDAndTitle();
 
   int64_t parent_id;
   return base::StringToInt64(value.substr(0, pos), &parent_id) ?
       ParentIDAndTitle(parent_id, value.substr(pos + 1)) : ParentIDAndTitle();
 }
 
 int64_t MetadataDatabaseIndexOnDisk::PickDirtyTracker() const {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   itr->Seek(kDirtyIDKeyPrefix);
   if (!itr->Valid())
     return kInvalidTrackerID;
 
   std::string id_str;
   if (!RemovePrefix(itr->key().ToString(), kDirtyIDKeyPrefix, &id_str))
     return kInvalidTrackerID;
 
   int64_t tracker_id;
   if (!base::StringToInt64(id_str, &tracker_id))
@@ skipping 16 matching lines @@
               tracker_id);
     return;
   }
 
   db_->Delete(key);
   db_->Put(GenerateDemotedDirtyIDKey(tracker_id), std::string());
   --num_dirty_trackers_;
 }
 
 bool MetadataDatabaseIndexOnDisk::HasDemotedDirtyTracker() const {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   itr->Seek(kDemotedDirtyIDKeyPrefix);
   if (!itr->Valid())
     return false;
   return base::StartsWith(itr->key().ToString(), kDemotedDirtyIDKeyPrefix,
                           base::CompareCase::SENSITIVE);
 }
 
 bool MetadataDatabaseIndexOnDisk::IsDemotedDirtyTracker(
     int64_t tracker_id) const {
   return DBHasKey(GenerateDemotedDirtyIDKey(tracker_id));
 }
 
 void MetadataDatabaseIndexOnDisk::PromoteDemotedDirtyTracker(
     int64_t tracker_id) {
   std::string demoted_key = GenerateDemotedDirtyIDKey(tracker_id);
 
   std::string empty;
   if (db_->Get(demoted_key, &empty).ok()) {
     db_->Delete(demoted_key);
     db_->Put(GenerateDirtyIDKey(tracker_id), std::string());
     ++num_dirty_trackers_;
   }
 }
 
 bool MetadataDatabaseIndexOnDisk::PromoteDemotedDirtyTrackers() {
   bool promoted = false;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kDemotedDirtyIDKeyPrefix); itr->Valid(); itr->Next()) {
     std::string id_str;
     if (!RemovePrefix(itr->key().ToString(), kDemotedDirtyIDKeyPrefix, &id_str))
       break;
 
     int64_t tracker_id;
     if (!base::StringToInt64(id_str, &tracker_id))
       continue;
 
     db_->Delete(itr->key().ToString());
     db_->Put(GenerateDirtyIDKey(tracker_id), std::string());
     ++num_dirty_trackers_;
     promoted = true;
   }
   return promoted;
 }
 
 size_t MetadataDatabaseIndexOnDisk::CountDirtyTracker() const {
   return num_dirty_trackers_;
 }
 
 size_t MetadataDatabaseIndexOnDisk::CountFileMetadata() const {
   // TODO(peria): Cache the number of FileMetadata in the DB.
   size_t count = 0;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileMetadataKeyPrefix); itr->Valid(); itr->Next()) {
     if (!base::StartsWith(itr->key().ToString(), kFileMetadataKeyPrefix,
                           base::CompareCase::SENSITIVE))
       break;
     ++count;
   }
   return count;
 }
 
 size_t MetadataDatabaseIndexOnDisk::CountFileTracker() const {
   // TODO(peria): Cache the number of FileTracker in the DB.
   size_t count = 0;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
     if (!base::StartsWith(itr->key().ToString(), kFileTrackerKeyPrefix,
                           base::CompareCase::SENSITIVE))
       break;
     ++count;
   }
   return count;
 }
 
 void MetadataDatabaseIndexOnDisk::SetSyncRootRevalidated() const {
@@ skipping 38 matching lines @@
 
 int64_t MetadataDatabaseIndexOnDisk::GetNextTrackerID() const {
   if (!service_metadata_->has_next_tracker_id())
     return kInvalidTrackerID;
   return service_metadata_->next_tracker_id();
 }
 
 std::vector<std::string>
 MetadataDatabaseIndexOnDisk::GetRegisteredAppIDs() const {
   std::vector<std::string> result;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kAppRootIDByAppIDKeyPrefix); itr->Valid(); itr->Next()) {
     std::string id;
     if (!RemovePrefix(itr->key().ToString(), kAppRootIDByAppIDKeyPrefix, &id))
       break;
     result.push_back(id);
   }
   return result;
 }
 
 std::vector<int64_t> MetadataDatabaseIndexOnDisk::GetAllTrackerIDs() const {
   std::vector<int64_t> tracker_ids;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
     std::string id_str;
     if (!RemovePrefix(itr->key().ToString(), kFileTrackerKeyPrefix, &id_str))
       break;
 
     int64_t tracker_id;
     if (!base::StringToInt64(id_str, &tracker_id))
       continue;
     tracker_ids.push_back(tracker_id);
   }
   return tracker_ids;
 }
 
 std::vector<std::string>
 MetadataDatabaseIndexOnDisk::GetAllMetadataIDs() const {
   std::vector<std::string> file_ids;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileMetadataKeyPrefix); itr->Valid(); itr->Next()) {
     std::string file_id;
     if (!RemovePrefix(itr->key().ToString(), kFileMetadataKeyPrefix, &file_id))
       break;
     file_ids.push_back(file_id);
   }
   return file_ids;
 }
 
 int64_t MetadataDatabaseIndexOnDisk::BuildTrackerIndexes() {
   int64_t num_puts_before = db_->num_puts();
 
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kFileTrackerKeyPrefix); itr->Valid(); itr->Next()) {
     if (!RemovePrefix(itr->key().ToString(), kFileTrackerKeyPrefix, nullptr))
       break;
 
     FileTracker tracker;
     if (!tracker.ParseFromString(itr->value().ToString())) {
       util::Log(logging::LOG_WARNING, FROM_HERE,
                 "Failed to parse a Tracker");
       continue;
     }
@@ skipping 173 matching lines @@
     const FileTracker& new_tracker) {
   int64_t parent_id = new_tracker.parent_tracker_id();
   std::string title = GetTrackerTitle(new_tracker);
 
   DVLOG(1) << "  Add to trackers by parent and title: "
            << parent_id << " " << title;
 
   const std::string prefix =
       GenerateTrackerIDByParentAndTitleKeyPrefix(parent_id, title);
   if (!title.empty()) {
-    scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+    std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
     for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
       std::string id_str;
       if (!RemovePrefix(itr->key().ToString(), prefix, &id_str))
         break;
 
       int64_t tracker_id;
       if (!base::StringToInt64(id_str, &tracker_id))
         continue;
       if (tracker_id == new_tracker.tracker_id()) {
         NOTREACHED();
@@ skipping 161 matching lines @@
     db_->Delete(demoted_key);
   }
 }
 
 TrackerIDSet MetadataDatabaseIndexOnDisk::GetTrackerIDSetByPrefix(
     const std::string& active_tracker_key,
     const std::string& ids_prefix) const {
   TrackerIDSet trackers;
 
   // Seek IDs.
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(ids_prefix); itr->Valid(); itr->Next()) {
     const std::string& key(itr->key().ToString());
     std::string id_str;
     if (!RemovePrefix(key, ids_prefix, &id_str))
       break;
 
     int64_t tracker_id;
     if (!base::StringToInt64(id_str, &tracker_id))
       continue;
     trackers.InsertInactiveTracker(tracker_id);
@@ skipping 69 matching lines @@
   std::string value;
   leveldb::Status status = db_->Get(active_tracker_key, &value);
   int64_t active_tracker_id;
   if (status.ok() && base::StringToInt64(value, &active_tracker_id)) {
     DCHECK(active_tracker_id == tracker_id);
     db_->Delete(active_tracker_key);
   }
 }
 
 bool MetadataDatabaseIndexOnDisk::DBHasKey(const std::string& key) const {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   itr->Seek(key);
   return itr->Valid() && (itr->key() == key);
 }
 
 size_t MetadataDatabaseIndexOnDisk::CountDirtyTrackerInternal() const {
   size_t num_dirty_trackers = 0;
 
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(kDirtyIDKeyPrefix); itr->Valid(); itr->Next()) {
     if (!base::StartsWith(itr->key().ToString(), kDirtyIDKeyPrefix,
                           base::CompareCase::SENSITIVE))
       break;
     ++num_dirty_trackers;
   }
 
   return num_dirty_trackers;
 }
 
 MetadataDatabaseIndexOnDisk::NumEntries
 MetadataDatabaseIndexOnDisk::CountWithPrefix(const std::string& prefix,
                                              int64_t ignored_id) {
   const std::string ignored = base::Int64ToString(ignored_id);
 
   size_t count = 0;
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(prefix); itr->Valid() && count <= 1; itr->Next()) {
     std::string value;
     if (!RemovePrefix(itr->key().ToString(), prefix, &value))
       break;
     if (value == ignored)
       continue;
 
     ++count;
   }
 
   if (count >= 2)
     return MULTIPLE;
   return count == 0 ? NONE : SINGLE;
 }
 
 void MetadataDatabaseIndexOnDisk::DeleteKeyStartsWith(
     const std::string& prefix) {
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db_->NewIterator());
   for (itr->Seek(prefix); itr->Valid();) {
     const std::string key = itr->key().ToString();
     if (!base::StartsWith(key, prefix, base::CompareCase::SENSITIVE))
       break;
     itr->Delete();
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system