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

chrome/browser/sync_file_system/drive_backend/metadata_database.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 "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
@@ skipping 79 matching lines @@
     details->set_file_kind(FILE_KIND_FILE);
 
   details->set_md5(file_resource.md5_checksum());
   details->set_etag(file_resource.etag());
   details->set_creation_time(file_resource.created_date().ToInternalValue());
   details->set_modification_time(
       file_resource.modified_date().ToInternalValue());
   details->set_missing(file_resource.labels().is_trashed());
 }
 
-scoped_ptr<FileMetadata> CreateFileMetadataFromFileResource(
+std::unique_ptr<FileMetadata> CreateFileMetadataFromFileResource(
     int64_t change_id,
     const google_apis::FileResource& resource) {
-  scoped_ptr<FileMetadata> file(new FileMetadata);
+  std::unique_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(resource.file_id());
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
 
   if (resource.labels().is_trashed()) {
     details->set_missing(true);
     return file;
   }
 
   PopulateFileDetailsByFileResource(resource, details);
   return file;
 }
 
-scoped_ptr<FileMetadata> CreateFileMetadataFromChangeResource(
+std::unique_ptr<FileMetadata> CreateFileMetadataFromChangeResource(
     const google_apis::ChangeResource& change) {
-  scoped_ptr<FileMetadata> file(new FileMetadata);
+  std::unique_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(change.file_id());
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change.change_id());
 
   if (change.is_deleted()) {
     details->set_missing(true);
     return file;
   }
 
   PopulateFileDetailsByFileResource(*change.file(), details);
   return file;
 }
 
-scoped_ptr<FileMetadata> CreateDeletedFileMetadata(int64_t change_id,
-                                                   const std::string& file_id) {
-  scoped_ptr<FileMetadata> file(new FileMetadata);
+std::unique_ptr<FileMetadata> CreateDeletedFileMetadata(
+    int64_t change_id,
+    const std::string& file_id) {
+  std::unique_ptr<FileMetadata> file(new FileMetadata);
   file->set_file_id(file_id);
 
   FileDetails* details = file->mutable_details();
   details->set_change_id(change_id);
   details->set_missing(true);
   return file;
 }
 
-scoped_ptr<FileTracker> CreateSyncRootTracker(
+std::unique_ptr<FileTracker> CreateSyncRootTracker(
     int64_t tracker_id,
     const FileMetadata& sync_root_metadata) {
-  scoped_ptr<FileTracker> sync_root_tracker(new FileTracker);
+  std::unique_ptr<FileTracker> sync_root_tracker(new FileTracker);
   sync_root_tracker->set_tracker_id(tracker_id);
   sync_root_tracker->set_file_id(sync_root_metadata.file_id());
   sync_root_tracker->set_parent_tracker_id(0);
   sync_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   sync_root_tracker->set_dirty(false);
   sync_root_tracker->set_active(true);
   sync_root_tracker->set_needs_folder_listing(false);
   *sync_root_tracker->mutable_synced_details() = sync_root_metadata.details();
   return sync_root_tracker;
 }
 
-scoped_ptr<FileTracker> CreateInitialAppRootTracker(
+std::unique_ptr<FileTracker> CreateInitialAppRootTracker(
     int64_t tracker_id,
     int64_t parent_tracker_id,
     const FileMetadata& app_root_metadata) {
-  scoped_ptr<FileTracker> app_root_tracker(new FileTracker);
+  std::unique_ptr<FileTracker> app_root_tracker(new FileTracker);
   app_root_tracker->set_tracker_id(tracker_id);
   app_root_tracker->set_parent_tracker_id(parent_tracker_id);
   app_root_tracker->set_file_id(app_root_metadata.file_id());
   app_root_tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   app_root_tracker->set_dirty(false);
   app_root_tracker->set_active(false);
   app_root_tracker->set_needs_folder_listing(false);
   *app_root_tracker->mutable_synced_details() = app_root_metadata.details();
   return app_root_tracker;
 }
 
-scoped_ptr<FileTracker> CloneFileTracker(const FileTracker* obj) {
+std::unique_ptr<FileTracker> CloneFileTracker(const FileTracker* obj) {
   if (!obj)
     return nullptr;
-  return scoped_ptr<FileTracker>(new FileTracker(*obj));
+  return std::unique_ptr<FileTracker>(new FileTracker(*obj));
 }
 
 // Returns true if |db| has no content.
 bool IsDatabaseEmpty(LevelDBWrapper* db) {
   DCHECK(db);
-  scoped_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
+  std::unique_ptr<LevelDBWrapper::Iterator> itr(db->NewIterator());
   itr->SeekToFirst();
   return !itr->Valid();
 }
 
 SyncStatusCode OpenDatabase(const base::FilePath& path,
                             leveldb::Env* env_override,
-                            scoped_ptr<LevelDBWrapper>* db_out,
+                            std::unique_ptr<LevelDBWrapper>* db_out,
                             bool* created) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db_out);
   DCHECK(created);
   DCHECK(path.IsAbsolute());
 
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = true;
   options.paranoid_checks = true;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
   if (env_override)
     options.env = env_override;
   leveldb::DB* db = nullptr;
   leveldb::Status db_status =
       leveldb::DB::Open(options, path.AsUTF8Unsafe(), &db);
   UMA_HISTOGRAM_ENUMERATION("SyncFileSystem.Database.Open",
                             leveldb_env::GetLevelDBStatusUMAValue(db_status),
                             leveldb_env::LEVELDB_STATUS_MAX);
   SyncStatusCode status = LevelDBStatusToSyncStatusCode(db_status);
   if (status != SYNC_STATUS_OK) {
     delete db;
     return status;
   }
 
-  db_out->reset(new LevelDBWrapper(make_scoped_ptr(db)));
+  db_out->reset(new LevelDBWrapper(base::WrapUnique(db)));
   *created = IsDatabaseEmpty(db_out->get());
   return status;
 }
 
 SyncStatusCode MigrateDatabaseIfNeeded(LevelDBWrapper* db) {
   // See metadata_database_index.cc for the database schema.
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(db);
   std::string value;
   leveldb::Status status = db->Get(kDatabaseVersionKey, &value);
@@ skipping 33 matching lines @@
 bool HasInvalidTitle(const std::string& title) {
   return title.empty() ||
       title.find('/') != std::string::npos ||
       title.find('\\') != std::string::npos;
 }
 
 void MarkTrackerSetDirty(const TrackerIDSet& trackers,
                          MetadataDatabaseIndexInterface* index) {
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
-    scoped_ptr<FileTracker> tracker(new FileTracker);
+    std::unique_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(*itr, tracker.get());
     if (tracker->dirty())
       continue;
     tracker->set_dirty(true);
     index->StoreFileTracker(std::move(tracker));
   }
 }
 
 void MarkTrackersDirtyByPath(int64_t parent_tracker_id,
                              const std::string& title,
@@ skipping 12 matching lines @@
 
 void MarkTrackersDirtyRecursively(int64_t root_tracker_id,
                                   MetadataDatabaseIndexInterface* index) {
   std::vector<int64_t> stack;
   stack.push_back(root_tracker_id);
   while (!stack.empty()) {
     int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index->GetFileTrackerIDsByParent(tracker_id), &stack);
 
-    scoped_ptr<FileTracker> tracker(new FileTracker);
+    std::unique_ptr<FileTracker> tracker(new FileTracker);
     index->GetFileTracker(tracker_id, tracker.get());
     tracker->set_dirty(true);
 
     index->StoreFileTracker(std::move(tracker));
   }
 }
 
 void RemoveAllDescendantTrackers(int64_t root_tracker_id,
                                  MetadataDatabaseIndexInterface* index) {
   std::vector<int64_t> pending_trackers;
@@ skipping 118 matching lines @@
   MARK_SAME_FILE_ID_TRACKERS_DIRTY = 1 << 1,
   MARK_SAME_PATH_TRACKERS_DIRTY = 1 << 2,
 };
 
 void ActivateFileTracker(int64_t tracker_id,
                          int dirtying_options,
                          MetadataDatabaseIndexInterface* index) {
   DCHECK(dirtying_options == MARK_NOTHING_DIRTY ||
          dirtying_options == MARK_ITSELF_DIRTY);
 
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
   tracker->set_active(true);
   if (dirtying_options & MARK_ITSELF_DIRTY) {
     tracker->set_dirty(true);
     tracker->set_needs_folder_listing(
         tracker->has_synced_details() &&
         tracker->synced_details().file_kind() == FILE_KIND_FOLDER);
   } else {
     tracker->set_dirty(false);
     tracker->set_needs_folder_listing(false);
   }
 
   index->StoreFileTracker(std::move(tracker));
 }
 
 void DeactivateFileTracker(int64_t tracker_id,
                            int dirtying_options,
                            MetadataDatabaseIndexInterface* index) {
   RemoveAllDescendantTrackers(tracker_id, index);
 
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   index->GetFileTracker(tracker_id, tracker.get());
 
   if (dirtying_options & MARK_SAME_FILE_ID_TRACKERS_DIRTY)
     MarkTrackersDirtyByFileID(tracker->file_id(), index);
   if (dirtying_options & MARK_SAME_PATH_TRACKERS_DIRTY) {
     MarkTrackersDirtyByPath(tracker->parent_tracker_id(),
                             GetTrackerTitle(*tracker), index);
   }
 
   tracker->set_dirty(dirtying_options & MARK_ITSELF_DIRTY);
@@ skipping 23 matching lines @@
     MarkTrackersDirtyByPath(parent_tracker_id, title, index);
 
   if (index->GetFileTrackerIDsByFileID(file_id).empty()) {
     index->RemoveFileMetadata(file_id);
   }
 }
 
 }  // namespace
 
 // static
-scoped_ptr<MetadataDatabase> MetadataDatabase::Create(
+std::unique_ptr<MetadataDatabase> MetadataDatabase::Create(
     const base::FilePath& database_path,
     leveldb::Env* env_override,
     SyncStatusCode* status_out) {
   bool enable_on_disk_index =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableMetadataDatabaseOnDisk);
   return CreateInternal(database_path, env_override, enable_on_disk_index,
                         status_out);
 }
 
 // static
-scoped_ptr<MetadataDatabase> MetadataDatabase::CreateInternal(
+std::unique_ptr<MetadataDatabase> MetadataDatabase::CreateInternal(
     const base::FilePath& database_path,
     leveldb::Env* env_override,
     bool enable_on_disk_index,
     SyncStatusCode* status_out) {
-  scoped_ptr<MetadataDatabase> metadata_database(
-      new MetadataDatabase(database_path,
-                           enable_on_disk_index,
-                           env_override));
+  std::unique_ptr<MetadataDatabase> metadata_database(
+      new MetadataDatabase(database_path, enable_on_disk_index, env_override));
 
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_DATABASE_ERROR_FAILED) {
     // Delete the previous instance to avoid creating a LevelDB instance for
     // the same path.
     metadata_database.reset();
 
     metadata_database.reset(
         new MetadataDatabase(database_path,
                              enable_on_disk_index,
                              env_override));
     status = metadata_database->Initialize();
   }
 
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
   *status_out = status;
   return metadata_database;
 }
 
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
-    scoped_ptr<LevelDBWrapper> db,
+    std::unique_ptr<LevelDBWrapper> db,
     bool enable_on_disk_index,
-    scoped_ptr<MetadataDatabase>* metadata_database_out) {
-  scoped_ptr<MetadataDatabase> metadata_database(
-      new MetadataDatabase(base::FilePath(),
-                           enable_on_disk_index,
-                           nullptr));
+    std::unique_ptr<MetadataDatabase>* metadata_database_out) {
+  std::unique_ptr<MetadataDatabase> metadata_database(
+      new MetadataDatabase(base::FilePath(), enable_on_disk_index, nullptr));
   metadata_database->db_ = std::move(db);
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_STATUS_OK)
     *metadata_database_out = std::move(metadata_database);
   return status;
 }
 
 MetadataDatabase::~MetadataDatabase() {
 }
 
 // static
 void MetadataDatabase::ClearDatabase(
-    scoped_ptr<MetadataDatabase> metadata_database) {
+    std::unique_ptr<MetadataDatabase> metadata_database) {
   DCHECK(metadata_database);
   base::FilePath database_path = metadata_database->database_path_;
   DCHECK(!database_path.empty());
   metadata_database.reset();
 
   base::DeleteFile(database_path, true /* recursive */);
 }
 
 int64_t MetadataDatabase::GetLargestFetchedChangeID() const {
   return index_->GetLargestChangeID();
@@ skipping 70 matching lines @@
     return SYNC_STATUS_HAS_CONFLICT;
   }
 
   int64_t sync_root_tracker_id = index_->GetSyncRootTrackerID();
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   if (!FilterFileTrackersByParent(index_.get(), trackers,
                                   sync_root_tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::DisableApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
   index_->StoreFileTracker(std::move(tracker));
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::EnableApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
     return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
     return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   index_->StoreFileTracker(std::move(tracker));
 
   MarkTrackersDirtyRecursively(tracker_id, index_.get());
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UnregisterApp(const std::string& app_id) {
   int64_t tracker_id = index_->GetAppRootTracker(app_id);
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
     return SYNC_STATUS_OK;
   }
 
   RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
@@ skipping 140 matching lines @@
 SyncStatusCode MetadataDatabase::UpdateByChangeList(
     int64_t largest_change_id,
     ScopedVector<google_apis::ChangeResource> changes) {
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
-    scoped_ptr<FileMetadata> metadata(
+    std::unique_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
     UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
   index_->SetLargestChangeID(largest_change_id);
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByFileResource(
     const google_apis::FileResource& resource) {
-  scoped_ptr<FileMetadata> metadata(
-      CreateFileMetadataFromFileResource(
-          GetLargestKnownChangeID(), resource));
+  std::unique_ptr<FileMetadata> metadata(
+      CreateFileMetadataFromFileResource(GetLargestKnownChangeID(), resource));
   UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByFileResourceList(
     ScopedVector<google_apis::FileResource> resources) {
   for (size_t i = 0; i < resources.size(); ++i) {
-    scoped_ptr<FileMetadata> metadata(
-        CreateFileMetadataFromFileResource(
-            GetLargestKnownChangeID(), *resources[i]));
+    std::unique_ptr<FileMetadata> metadata(CreateFileMetadataFromFileResource(
+        GetLargestKnownChangeID(), *resources[i]));
     UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFile(
     const std::string& file_id) {
-  scoped_ptr<FileMetadata> metadata(
+  std::unique_ptr<FileMetadata> metadata(
       CreateDeletedFileMetadata(GetLargestKnownChangeID(), file_id));
   UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFileList(
     const FileIDList& file_ids) {
   for (FileIDList::const_iterator itr = file_ids.begin();
        itr != file_ids.end(); ++itr) {
-    scoped_ptr<FileMetadata> metadata(
+    std::unique_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
     UpdateByFileMetadata(FROM_HERE, std::move(metadata),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
   return WriteToDatabase();
 }
 
 SyncStatusCode MetadataDatabase::ReplaceActiveTrackerWithNewResource(
     int64_t parent_tracker_id,
     const google_apis::FileResource& resource) {
@@ skipping 33 matching lines @@
 SyncStatusCode MetadataDatabase::PopulateFolderByChildList(
     const std::string& folder_id,
     const FileIDList& child_file_ids) {
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (!trackers.has_active()) {
     // It's OK that there is no folder to populate its children.
     // Inactive folders should ignore their contents updates.
     return SYNC_STATUS_OK;
   }
 
-  scoped_ptr<FileTracker> folder_tracker(new FileTracker);
+  std::unique_ptr<FileTracker> folder_tracker(new FileTracker);
   if (!index_->GetFileTracker(trackers.active_tracker(),
                               folder_tracker.get())) {
     NOTREACHED();
     return SYNC_STATUS_FAILED;
   }
 
   base::hash_set<std::string> children(child_file_ids.begin(),
                                        child_file_ids.end());
 
   std::vector<int64_t> known_children =
@@ skipping 82 matching lines @@
               tracker.file_id(),
               nullptr)) {
         RemoveFileTracker(tracker.tracker_id(),
                           MARK_NOTHING_DIRTY,
                           index_.get());
         return WriteToDatabase();
       }
     }
   }
 
-  scoped_ptr<FileTracker> updated_tracker = CloneFileTracker(&tracker);
+  std::unique_ptr<FileTracker> updated_tracker = CloneFileTracker(&tracker);
   *updated_tracker->mutable_synced_details() = updated_details;
 
   bool should_promote = false;
 
   // Activate the tracker if:
   //   - There is no active tracker that tracks |tracker->file_id()|.
   //   - There is no active tracker that has the same |parent| and |title|.
   if (!tracker.active() && CanActivateTracker(tracker)) {
     updated_tracker->set_active(true);
     updated_tracker->set_dirty(true);
@@ skipping 18 matching lines @@
   if (!index_->GetFileMetadata(file_id, &metadata)) {
     NOTREACHED();
     *status_out = SYNC_STATUS_FAILED;
     return ACTIVATION_PENDING;
   }
   std::string title = metadata.details().title();
   DCHECK(!HasInvalidTitle(title));
 
   TrackerIDSet same_file_id_trackers =
       index_->GetFileTrackerIDsByFileID(file_id);
-  scoped_ptr<FileTracker> tracker_to_be_activated(new FileTracker);
+  std::unique_ptr<FileTracker> tracker_to_be_activated(new FileTracker);
   FilterFileTrackersByParentAndTitle(
       index_.get(), same_file_id_trackers, parent_tracker_id,
       title, tracker_to_be_activated.get());
 
   // Check if there is another active tracker that tracks |file_id|.
   // This can happen when the tracked file has multiple parents.
   // In this case, report the failure to the caller.
   if (!tracker_to_be_activated->active() && same_file_id_trackers.has_active())
     return ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER;
 
   if (!tracker_to_be_activated->active()) {
     // Check if there exists another active tracker that has the same path to
     // the tracker.  If there is, deactivate it, assuming the caller already
     // overrides local file with newly added file,
     TrackerIDSet same_title_trackers =
         index_->GetFileTrackerIDsByParentAndTitle(parent_tracker_id, title);
     if (same_title_trackers.has_active()) {
       RemoveAllDescendantTrackers(same_title_trackers.active_tracker(),
                                   index_.get());
 
-      scoped_ptr<FileTracker> tracker_to_be_deactivated(new FileTracker);
+      std::unique_ptr<FileTracker> tracker_to_be_deactivated(new FileTracker);
       if (index_->GetFileTracker(same_title_trackers.active_tracker(),
                                  tracker_to_be_deactivated.get())) {
         const std::string file_id = tracker_to_be_deactivated->file_id();
         tracker_to_be_deactivated->set_active(false);
         index_->StoreFileTracker(std::move(tracker_to_be_deactivated));
 
         MarkTrackersDirtyByFileID(file_id, index_.get());
       } else {
         NOTREACHED();
       }
@@ skipping 115 matching lines @@
   for (size_t i = 0; i < file_ids.size(); ++i) {
     TrackerIDSet trackers_for_file_id =
         index_->GetFileTrackerIDsByFileID(file_ids[i]);
     for (TrackerIDSet::iterator itr = trackers_for_file_id.begin();
          itr != trackers_for_file_id.end(); ++itr)
       tracker_ids.insert(*itr);
   }
 
   for (std::set<int64_t>::iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
-    scoped_ptr<FileTracker> tracker(new FileTracker);
+    std::unique_ptr<FileTracker> tracker(new FileTracker);
     if (!index_->GetFileTracker(*itr, tracker.get()) ||
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
     index_->StoreFileTracker(std::move(tracker));
   }
 
   return WriteToDatabase();
 }
 
@@ skipping 25 matching lines @@
   }
 
   if (enable_on_disk_index_) {
     index_ = MetadataDatabaseIndexOnDisk::Create(db_.get());
   } else {
     index_ = MetadataDatabaseIndex::Create(db_.get());
   }
   if (!index_) {
     // Delete all entries in |db_| to reset it.
     // TODO(peria): Make LevelDBWrapper::DestroyDB() to avoid a full scan.
-    scoped_ptr<LevelDBWrapper::Iterator> itr = db_->NewIterator();
+    std::unique_ptr<LevelDBWrapper::Iterator> itr = db_->NewIterator();
     for (itr->SeekToFirst(); itr->Valid();)
       itr->Delete();
     db_->Commit();
 
     return SYNC_DATABASE_ERROR_FAILED;
   }
 
   status = LevelDBStatusToSyncStatusCode(db_->Commit());
   if (status != SYNC_STATUS_OK)
     return status;
@@ skipping 19 matching lines @@
                         file_metadata.file_id(),
                         &file_metadata.details(),
                         option);
 }
 
 void MetadataDatabase::CreateTrackerInternal(const FileTracker& parent_tracker,
                                              const std::string& file_id,
                                              const FileDetails* details,
                                              UpdateOption option) {
   int64_t tracker_id = IncrementTrackerID();
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   tracker->set_tracker_id(tracker_id);
   tracker->set_parent_tracker_id(parent_tracker.tracker_id());
   tracker->set_file_id(file_id);
   tracker->set_app_id(parent_tracker.app_id());
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_dirty(true);
   tracker->set_active(false);
   tracker->set_needs_folder_listing(false);
   if (details) {
     *tracker->mutable_synced_details() = *details;
@@ skipping 149 matching lines @@
     }
 
     if (!tracker.has_synced_details() || tracker.synced_details().missing()) {
       RemoveFileTracker(*itr, MARK_NOTHING_DIRTY, index_.get());
     }
   }
 }
 
 void MetadataDatabase::UpdateByFileMetadata(
     const tracked_objects::Location& from_where,
-    scoped_ptr<FileMetadata> metadata,
+    std::unique_ptr<FileMetadata> metadata,
     UpdateOption option) {
   DCHECK(metadata);
   DCHECK(metadata->has_details());
 
   DVLOG(1) << from_where.function_name() << ": "
            << metadata->file_id() << " ("
            << metadata->details().title() << ")"
            << (metadata->details().missing() ? " deleted" : "");
 
   std::string file_id = metadata->file_id();
   if (metadata->details().missing())
     RemoveUnneededTrackersForMissingFile(file_id);
   else
     MaybeAddTrackersForNewFile(*metadata, option);
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (!trackers.empty()) {
     index_->StoreFileMetadata(std::move(metadata));
 
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
       MarkTrackerSetDirty(trackers, index_.get());
   }
 }
 
 
 SyncStatusCode MetadataDatabase::WriteToDatabase() {
   return LevelDBStatusToSyncStatusCode(db_->Commit());
 }
 
-scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
+std::unique_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
-  scoped_ptr<base::ListValue> files(new base::ListValue);
+  std::unique_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
     return files;
 
   std::vector<int64_t> stack;
   AppendContents(
       index_->GetFileTrackerIDsByParent(app_root_tracker.tracker_id()), &stack);
   while (!stack.empty()) {
     int64_t tracker_id = stack.back();
@@ skipping 24 matching lines @@
     details->SetString("dirty", tracker.dirty() ? "true" : "false");
 
     file->Set("details", details);
 
     files->Append(file);
   }
 
   return files;
 }
 
-scoped_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
-  scoped_ptr<base::ListValue> list(new base::ListValue);
+std::unique_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
+  std::unique_ptr<base::ListValue> list(new base::ListValue);
   list->Append(DumpTrackers().release());
   list->Append(DumpMetadata().release());
   return list;
 }
 
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
                                             int64_t change_id) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata))
     return false;
   DCHECK(metadata.has_details());
   return metadata.details().change_id() >= change_id;
 }
 
-scoped_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
-  scoped_ptr<base::ListValue> trackers(new base::ListValue);
+std::unique_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
+  std::unique_ptr<base::ListValue> trackers(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *trackerKeys[] = {
     "tracker_id", "path", "file_id", "tracker_kind", "app_id",
     "active", "dirty", "folder_listing", "demoted",
     "title", "kind", "md5", "etag", "missing", "change_id",
   };
   std::vector<std::string> key_strings(
       trackerKeys, trackerKeys + arraysize(trackerKeys));
@@ skipping 41 matching lines @@
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
     }
     trackers->Append(dict);
   }
   return trackers;
 }
 
-scoped_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
-  scoped_ptr<base::ListValue> files(new base::ListValue);
+std::unique_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
+  std::unique_ptr<base::ListValue> files(new base::ListValue);
 
   // Append the first element for metadata.
   base::DictionaryValue* metadata = new base::DictionaryValue;
   const char *fileKeys[] = {
     "file_id", "title", "type", "md5", "etag", "missing",
     "change_id", "parents"
   };
   std::vector<std::string> key_strings(
       fileKeys, fileKeys + arraysize(fileKeys));
   base::ListValue* keys = new base::ListValue;
@@ skipping 29 matching lines @@
         parents.push_back(details.parent_folder_ids(i));
       dict->SetString("parents", base::JoinString(parents, ","));
     }
     files->Append(dict);
   }
   return files;
 }
 
 void MetadataDatabase::AttachSyncRoot(
     const google_apis::FileResource& sync_root_folder) {
-  scoped_ptr<FileMetadata> sync_root_metadata =
-      CreateFileMetadataFromFileResource(
-          GetLargestKnownChangeID(), sync_root_folder);
-  scoped_ptr<FileTracker> sync_root_tracker =
+  std::unique_ptr<FileMetadata> sync_root_metadata =
+      CreateFileMetadataFromFileResource(GetLargestKnownChangeID(),
+                                         sync_root_folder);
+  std::unique_ptr<FileTracker> sync_root_tracker =
       CreateSyncRootTracker(IncrementTrackerID(), *sync_root_metadata);
 
   index_->SetSyncRootTrackerID(sync_root_tracker->tracker_id());
   index_->StoreFileMetadata(std::move(sync_root_metadata));
   index_->StoreFileTracker(std::move(sync_root_tracker));
 }
 
 void MetadataDatabase::AttachInitialAppRoot(
     const google_apis::FileResource& app_root_folder) {
-  scoped_ptr<FileMetadata> app_root_metadata =
-      CreateFileMetadataFromFileResource(
-          GetLargestKnownChangeID(), app_root_folder);
-  scoped_ptr<FileTracker> app_root_tracker =
-      CreateInitialAppRootTracker(IncrementTrackerID(),
-                                  GetSyncRootTrackerID(),
-                                  *app_root_metadata);
+  std::unique_ptr<FileMetadata> app_root_metadata =
+      CreateFileMetadataFromFileResource(GetLargestKnownChangeID(),
+                                         app_root_folder);
+  std::unique_ptr<FileTracker> app_root_tracker = CreateInitialAppRootTracker(
+      IncrementTrackerID(), GetSyncRootTrackerID(), *app_root_metadata);
 
   index_->StoreFileMetadata(std::move(app_root_metadata));
   index_->StoreFileTracker(std::move(app_root_tracker));
 }
 
 bool MetadataDatabase::CanClearDirty(const FileTracker& tracker) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
       !tracker.active() || !tracker.dirty() ||
       !tracker.has_synced_details() ||
@@ skipping 16 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system