Make FileSystemOperation NOT self-destruct

chrome/browser/media_galleries/fileapi/device_media_async_file_util.cc

 // Copyright (c) 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/media_galleries/fileapi/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
@@ skipping 64 matching lines @@
 }
 
 // static
 DeviceMediaAsyncFileUtil* DeviceMediaAsyncFileUtil::Create(
     const base::FilePath& profile_path) {
   DCHECK(!profile_path.empty());
   return new DeviceMediaAsyncFileUtil(profile_path);
 }
 
 bool DeviceMediaAsyncFileUtil::CreateOrOpen(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int file_flags,
     const CreateOrOpenCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null()) {
     base::PlatformFile invalid_file = base::kInvalidPlatformFileValue;
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
                  base::PassPlatformFile(&invalid_file),
                  false);
   }
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::EnsureFileExists(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const EnsureFileExistsCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, false);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::CreateDirectory(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::GetFileInfo(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const GetFileInfoCallback& callback) {
-  DCHECK(IsOnIOThread(context));
-  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
+  DCHECK(IsOnIOThread(context.get()));
+  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context.get());
   if (!delegate) {
     OnGetFileInfoError(callback, url.path(),
                        base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return true;
   }
   delegate->GetFileInfo(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidGetFileInfo,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  url.path()),
       base::Bind(&DeviceMediaAsyncFileUtil::OnGetFileInfoError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  url.path()));
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::ReadDirectory(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
-  DCHECK(IsOnIOThread(context));
-  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
+  DCHECK(IsOnIOThread(context.get()));
+  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context.get());
   if (!delegate) {
     OnReadDirectoryError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return true;
   }
   delegate->ReadDirectory(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidReadDirectory,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&DeviceMediaAsyncFileUtil::OnReadDirectoryError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::Touch(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::Truncate(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int64 length,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::CopyFileLocal(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::MoveFileLocal(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::CopyInForeignFile(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::DeleteFile(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::DeleteDirectory(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   NOTIMPLEMENTED();
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
   return true;
 }
 
 bool DeviceMediaAsyncFileUtil::CreateSnapshotFile(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
-  DCHECK(IsOnIOThread(context));
-  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
+  DCHECK(IsOnIOThread(context.get()));
+  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context.get());
   if (!delegate) {
     OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return true;
   }
   base::FilePath* snapshot_file_path = new base::FilePath;
-  return context->task_runner()->PostTaskAndReply(
+  base::SequencedTaskRunner* task_runner = context->task_runner();
+  return task_runner->PostTaskAndReply(
           FROM_HERE,
           base::Bind(&CreateSnapshotFileOnBlockingPool,
                      url.path(),
                      profile_path_,
                      base::Unretained(snapshot_file_path)),
           base::Bind(&DeviceMediaAsyncFileUtil::OnSnapshotFileCreatedRunTask,
                      weak_ptr_factory_.GetWeakPtr(),
-                     context,
+                     base::Passed(&context),
                      callback,
                      url.path(),
                      base::Owned(snapshot_file_path)));
 }
 
 DeviceMediaAsyncFileUtil::DeviceMediaAsyncFileUtil(
     const base::FilePath& profile_path)
     : profile_path_(profile_path),
       weak_ptr_factory_(this) {
 }
@@ skipping 65 matching lines @@
 
 void DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::PlatformFileError error) {
   if (!callback.is_null())
     callback.Run(error, base::PlatformFileInfo(), base::FilePath(),
                  scoped_refptr<ShareableFileReference>());
 }
 
 void DeviceMediaAsyncFileUtil::OnSnapshotFileCreatedRunTask(
-    FileSystemOperationContext* context,
+    scoped_ptr<FileSystemOperationContext> context,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const base::FilePath& device_file_path,
     base::FilePath* snapshot_file_path) {
-  DCHECK(IsOnIOThread(context));
+  DCHECK(IsOnIOThread(context.get()));
   if (!snapshot_file_path || snapshot_file_path->empty()) {
     OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_FAILED);
     return;
   }
-  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
+  MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context.get());
   if (!delegate) {
     OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->CreateSnapshotFile(
       device_file_path,
       *snapshot_file_path,
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  make_scoped_refptr(context->task_runner())),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 }  // namespace chrome