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

chrome/browser/sync_file_system/local/local_file_change_tracker.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/local/local_file_change_tracker.h"
 
 #include <stddef.h>
 #include <queue>
 #include <utility>
 
@@ skipping 32 matching lines @@
 // object must be destructed on file_task_runner.
 class LocalFileChangeTracker::TrackerDB {
  public:
   TrackerDB(const base::FilePath& base_path,
             leveldb::Env* env_override);
 
   SyncStatusCode MarkDirty(const std::string& url);
   SyncStatusCode ClearDirty(const std::string& url);
   SyncStatusCode GetDirtyEntries(
       std::queue<FileSystemURL>* dirty_files);
-  SyncStatusCode WriteBatch(scoped_ptr<leveldb::WriteBatch> batch);
+  SyncStatusCode WriteBatch(std::unique_ptr<leveldb::WriteBatch> batch);
 
  private:
   enum RecoveryOption {
     REPAIR_ON_CORRUPTION,
     FAIL_ON_CORRUPTION,
   };
 
   SyncStatusCode Init(RecoveryOption recovery_option);
   SyncStatusCode Repair(const std::string& db_path);
   void HandleError(const tracked_objects::Location& from_here,
                    const leveldb::Status& status);
 
   const base::FilePath base_path_;
   leveldb::Env* env_override_;
-  scoped_ptr<leveldb::DB> db_;
+  std::unique_ptr<leveldb::DB> db_;
   SyncStatusCode db_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackerDB);
 };
 
 LocalFileChangeTracker::ChangeInfo::ChangeInfo() : change_seq(-1) {}
 LocalFileChangeTracker::ChangeInfo::~ChangeInfo() {}
 
 // LocalFileChangeTracker ------------------------------------------------------
 
@@ skipping 191 matching lines @@
 
   SyncStatusCode status = CollectLastDirtyChanges(file_system_context);
   if (status == SYNC_STATUS_OK)
     initialized_ = true;
   return status;
 }
 
 void LocalFileChangeTracker::ResetForFileSystem(const GURL& origin,
                                                 storage::FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
-  scoped_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
+  std::unique_ptr<leveldb::WriteBatch> batch(new leveldb::WriteBatch);
   for (FileChangeMap::iterator iter = changes_.begin();
        iter != changes_.end();) {
     storage::FileSystemURL url = iter->first;
     int change_seq = iter->second.change_seq;
     // Advance |iter| before calling ResetForURL to avoid the iterator
     // invalidation in it.
     ++iter;
     if (url.origin() == origin && url.type() == type)
       ResetForURL(url, change_seq, batch.get());
   }
@@ skipping 60 matching lines @@
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
 
   std::queue<FileSystemURL> dirty_files;
   const SyncStatusCode status = tracker_db_->GetDirtyEntries(&dirty_files);
   if (status != SYNC_STATUS_OK)
     return status;
 
   FileSystemFileUtil* file_util =
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
-  scoped_ptr<FileSystemOperationContext> context(
+  std::unique_ptr<FileSystemOperationContext> context(
       new FileSystemOperationContext(file_system_context));
 
   base::File::Info file_info;
   base::FilePath platform_path;
 
   while (!dirty_files.empty()) {
     const FileSystemURL url = dirty_files.front();
     dirty_files.pop();
     DCHECK_EQ(url.type(), storage::kFileSystemTypeSyncable);
 
     switch (file_util->GetFileInfo(context.get(), url,
                                    &file_info, &platform_path)) {
       case base::File::FILE_OK: {
         if (!file_info.is_directory) {
           RecordChange(url, FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                                        SYNC_FILE_TYPE_FILE));
           break;
         }
 
         RecordChange(url, FileChange(
             FileChange::FILE_CHANGE_ADD_OR_UPDATE,
             SYNC_FILE_TYPE_DIRECTORY));
 
         // Push files and directories in this directory into |dirty_files|.
-        scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
+        std::unique_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
             file_util->CreateFileEnumerator(context.get(), url));
         base::FilePath path_each;
         while (!(path_each = enumerator->Next()).empty()) {
           dirty_files.push(CreateSyncableFileSystemURL(
                   url.origin(), path_each));
         }
         break;
       }
       case base::File::FILE_ERROR_NOT_FOUND: {
         // File represented by |url| has already been deleted. Since we cannot
@@ skipping 187 matching lines @@
     std::queue<FileSystemURL>* dirty_files) {
   if (db_status_ != SYNC_STATUS_OK)
     return db_status_;
 
   db_status_ = Init(REPAIR_ON_CORRUPTION);
   if (db_status_ != SYNC_STATUS_OK) {
     db_.reset();
     return db_status_;
   }
 
-  scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(leveldb::ReadOptions()));
+  std::unique_ptr<leveldb::Iterator> iter(
+      db_->NewIterator(leveldb::ReadOptions()));
   iter->SeekToFirst();
   FileSystemURL url;
   while (iter->Valid()) {
     if (!DeserializeSyncableFileSystemURL(iter->key().ToString(), &url)) {
       LOG(WARNING) << "Failed to deserialize an URL. "
                    << "TrackerDB might be corrupted.";
       db_status_ = SYNC_DATABASE_ERROR_CORRUPTION;
       iter.reset();  // Must delete before closing the database.
       db_.reset();
       return db_status_;
     }
     dirty_files->push(url);
     iter->Next();
   }
   return SYNC_STATUS_OK;
 }
 
 SyncStatusCode LocalFileChangeTracker::TrackerDB::WriteBatch(
-    scoped_ptr<leveldb::WriteBatch> batch) {
+    std::unique_ptr<leveldb::WriteBatch> batch) {
   if (db_status_ != SYNC_STATUS_OK)
     return db_status_;
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch.get());
   if (!status.ok() && !status.IsNotFound()) {
     HandleError(FROM_HERE, status);
     db_status_ = LevelDBStatusToSyncStatusCode(status);
     db_.reset();
     return db_status_;
   }
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system