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

chrome/browser/sync_file_system/local/canned_syncable_file_system.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/canned_syncable_file_system.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
@@ skipping 169 matching lines @@
       if (!complete)
         return;
     }
     completion_callback.Run(error == base::File::FILE_OK
                                 ? bytes_written_
                                 : static_cast<int64_t>(error));
   }
 
  private:
   int64_t bytes_written_;
-  scoped_ptr<MockBlobURLRequestContext> request_context_;
-  scoped_ptr<ScopedTextBlob> blob_data_;
+  std::unique_ptr<MockBlobURLRequestContext> request_context_;
+  std::unique_ptr<ScopedTextBlob> blob_data_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
 void DidGetUsageAndQuota(const storage::StatusCallback& callback,
                          int64_t* usage_out,
                          int64_t* quota_out,
                          storage::QuotaStatusCode status,
                          int64_t usage,
                          int64_t quota) {
@@ skipping 265 matching lines @@
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoReadDirectory,
                  base::Unretained(this),
                  url,
                  entries));
 }
 
 int64_t CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
-    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
   return RunOnThread<int64_t>(
       io_task_runner_.get(), FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoWrite, base::Unretained(this),
                  url_request_context, url, base::Passed(&blob_data_handle)));
 }
 
 int64_t CannedSyncableFileSystem::WriteString(const FileSystemURL& url,
                                               const std::string& data) {
   return RunOnThread<int64_t>(
       io_task_runner_.get(), FROM_HERE,
@@ skipping 190 matching lines @@
     const StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->ReadDirectory(
       url, base::Bind(&OnReadDirectory, entries, callback));
 }
 
 void CannedSyncableFileSystem::DoWrite(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
-    scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
     const WriteCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   WriteHelper* helper = new WriteHelper;
   operation_runner()->Write(
       url_request_context, url, std::move(blob_data_handle), 0,
       base::Bind(&WriteHelper::DidWrite, base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoWriteString(
@@ skipping 56 matching lines @@
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system