Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

storage/browser/fileapi/file_system_operation_runner.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 "storage/browser/fileapi/file_system_operation_runner.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <tuple>
@@ skipping 34 matching lines @@
 
 void FileSystemOperationRunner::Shutdown() {
   operations_.Clear();
 }
 
 OperationID FileSystemOperationRunner::CreateFile(
     const FileSystemURL& url,
     bool exclusive,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
-
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->CreateFile(
+  operation_raw->CreateFile(
       url, exclusive,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::CreateDirectory(
     const FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->CreateDirectory(
+  operation_raw->CreateDirectory(
       url, exclusive, recursive,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Copy(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     ErrorBehavior error_behavior,
     const CopyProgressCallback& progress_callback,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(dest_url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(dest_url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, dest_url);
   PrepareForRead(handle.id, src_url);
-  operation->Copy(src_url, dest_url, option, error_behavior,
+  operation_raw->Copy(src_url, dest_url, option, error_behavior,
                   progress_callback.is_null()
                       ? CopyProgressCallback()
                       : base::Bind(&FileSystemOperationRunner::OnCopyProgress,
                                    AsWeakPtr(), handle, progress_callback),
                   base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                              handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Move(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(dest_url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(dest_url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, dest_url);
   PrepareForWrite(handle.id, src_url);
-  operation->Move(
+  operation_raw->Move(
       src_url, dest_url, option,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::DirectoryExists(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForRead(handle.id, url);
-  operation->DirectoryExists(
+  operation_raw->DirectoryExists(
       url,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::FileExists(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForRead(handle.id, url);
-  operation->FileExists(
+  operation_raw->FileExists(
       url,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::GetMetadata(
     const FileSystemURL& url,
     int fields,
     const GetMetadataCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidGetMetadata(handle, callback, error, base::File::Info());
     return handle.id;
   }
   PrepareForRead(handle.id, url);
-  operation->GetMetadata(url, fields,
+  operation_raw->GetMetadata(url, fields,
                          base::Bind(&FileSystemOperationRunner::DidGetMetadata,
                                     AsWeakPtr(), handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::ReadDirectory(
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidReadDirectory(handle, callback, error, std::vector<DirectoryEntry>(),
                      false);
     return handle.id;
   }
   PrepareForRead(handle.id, url);
-  operation->ReadDirectory(
+  operation_raw->ReadDirectory(
       url,
       base::Bind(&FileSystemOperationRunner::DidReadDirectory, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Remove(
     const FileSystemURL& url, bool recursive,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->Remove(
+  operation_raw->Remove(
       url, recursive,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Write(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     std::unique_ptr<storage::BlobDataHandle> blob,
     int64_t offset,
     const WriteCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
-
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidWrite(handle, callback, error, 0, true);
     return handle.id;
   }
 
   std::unique_ptr<FileStreamWriter> writer(
       file_system_context_->CreateFileStreamWriter(url, offset));
   if (!writer) {
     // Write is not supported.
     DidWrite(handle, callback, base::File::FILE_ERROR_SECURITY, 0, true);
     return handle.id;
   }
 
   std::unique_ptr<FileWriterDelegate> writer_delegate(new FileWriterDelegate(
       std::move(writer), url.mount_option().flush_policy()));
 
   std::unique_ptr<net::URLRequest> blob_request(
       storage::BlobProtocolHandler::CreateBlobRequest(
           std::move(blob), url_request_context, writer_delegate.get()));
 
   PrepareForWrite(handle.id, url);
-  operation->Write(url, std::move(writer_delegate), std::move(blob_request),
+  operation_raw->Write(url, std::move(writer_delegate), std::move(blob_request),
                    base::Bind(&FileSystemOperationRunner::DidWrite, AsWeakPtr(),
                               handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::Truncate(
     const FileSystemURL& url,
     int64_t length,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->Truncate(
+  operation_raw->Truncate(
       url, length,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 void FileSystemOperationRunner::Cancel(
     OperationID id,
     const StatusCallback& callback) {
   if (base::ContainsKey(finished_operations_, id)) {
     DCHECK(!base::ContainsKey(stray_cancel_callbacks_, id));
     stray_cancel_callbacks_[id] = callback;
     return;
   }
   FileSystemOperation* operation = operations_.Lookup(id);
   if (!operation) {
     // There is no operation with |id|.
     callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     return;
   }
   operation->Cancel(callback);
 }
 
 OperationID FileSystemOperationRunner::TouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->TouchFile(
+  operation_raw->TouchFile(
       url, last_access_time, last_modified_time,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::OpenFile(
     const FileSystemURL& url,
     int file_flags,
     const OpenFileCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidOpenFile(handle, callback, base::File(error), base::Closure());
     return handle.id;
   }
   if (file_flags &
       (base::File::FLAG_CREATE | base::File::FLAG_OPEN_ALWAYS |
        base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_OPEN_TRUNCATED |
        base::File::FLAG_WRITE | base::File::FLAG_EXCLUSIVE_WRITE |
        base::File::FLAG_DELETE_ON_CLOSE |
        base::File::FLAG_WRITE_ATTRIBUTES)) {
     PrepareForWrite(handle.id, url);
   } else {
     PrepareForRead(handle.id, url);
   }
-  operation->OpenFile(
+  operation_raw->OpenFile(
       url, file_flags,
       base::Bind(&FileSystemOperationRunner::DidOpenFile, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidCreateSnapshot(handle, callback, error, base::File::Info(),
                       base::FilePath(), NULL);
     return handle.id;
   }
   PrepareForRead(handle.id, url);
-  operation->CreateSnapshotFile(
+  operation_raw->CreateSnapshotFile(
       url,
       base::Bind(&FileSystemOperationRunner::DidCreateSnapshot, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::CopyInForeignFile(
     const base::FilePath& src_local_disk_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(dest_url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(dest_url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, dest_url);
-  operation->CopyInForeignFile(
+  operation_raw->CopyInForeignFile(
       src_local_disk_path, dest_url,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->RemoveFile(
+  operation_raw->RemoveFile(
       url,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::RemoveDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, url);
-  operation->RemoveDirectory(
+  operation_raw->RemoveDirectory(
       url,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::CopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const CopyFileProgressCallback& progress_callback,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(src_url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(src_url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForRead(handle.id, src_url);
   PrepareForWrite(handle.id, dest_url);
-  operation->CopyFileLocal(
+  operation_raw->CopyFileLocal(
       src_url, dest_url, option, progress_callback,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 OperationID FileSystemOperationRunner::MoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     CopyOrMoveOption option,
     const StatusCallback& callback) {
   base::File::Error error = base::File::FILE_OK;
-  FileSystemOperation* operation =
-      file_system_context_->CreateFileSystemOperation(src_url, &error);
+  std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
+      file_system_context_->CreateFileSystemOperation(src_url, &error));
+  FileSystemOperation* operation_raw = operation.get();
   BeginOperationScoper scope;
-  OperationHandle handle = BeginOperation(operation, scope.AsWeakPtr());
-  if (!operation) {
+  OperationHandle handle =
+      BeginOperation(std::move(operation), scope.AsWeakPtr());
+  if (!operation_raw) {
     DidFinish(handle, callback, error);
     return handle.id;
   }
   PrepareForWrite(handle.id, src_url);
   PrepareForWrite(handle.id, dest_url);
-  operation->MoveFileLocal(
+  operation_raw->MoveFileLocal(
       src_url, dest_url, option,
       base::Bind(&FileSystemOperationRunner::DidFinish, AsWeakPtr(),
                  handle, callback));
   return handle.id;
 }
 
 base::File::Error FileSystemOperationRunner::SyncGetPlatformPath(
     const FileSystemURL& url,
     base::FilePath* platform_path) {
   base::File::Error error = base::File::FILE_OK;
@@ skipping 140 matching lines @@
 void FileSystemOperationRunner::PrepareForRead(OperationID id,
                                                const FileSystemURL& url) {
   if (file_system_context_->GetAccessObservers(url.type())) {
     file_system_context_->GetAccessObservers(url.type())->Notify(
         &FileAccessObserver::OnAccess, std::make_tuple(url));
   }
 }
 
 FileSystemOperationRunner::OperationHandle
 FileSystemOperationRunner::BeginOperation(
-    FileSystemOperation* operation,
+    std::unique_ptr<FileSystemOperation> operation,
     base::WeakPtr<BeginOperationScoper> scope) {
   OperationHandle handle;
-  handle.id = operations_.Add(operation);
+  handle.id = operations_.Add(std::move(operation));
   handle.scope = scope;
   return handle;
 }
 
 void FileSystemOperationRunner::FinishOperation(OperationID id) {
   OperationToURLSet::iterator found = write_target_urls_.find(id);
   if (found != write_target_urls_.end()) {
     const FileSystemURLSet& urls = found->second;
     for (FileSystemURLSet::const_iterator iter = urls.begin();
         iter != urls.end(); ++iter) {
@@ skipping 16 matching lines @@
       stray_cancel_callbacks_.find(id);
   if (found_cancel != stray_cancel_callbacks_.end()) {
     // This cancel has been requested after the operation has finished,
     // so report that we failed to stop it.
     found_cancel->second.Run(base::File::FILE_ERROR_INVALID_OPERATION);
     stray_cancel_callbacks_.erase(found_cancel);
   }
 }
 
 }  // namespace storage