Change some snapshot- or temporary-file related changes to use ScopedFile

webkit/fileapi/media/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 "webkit/fileapi/media/device_media_async_file_util.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/single_thread_task_runner.h"
+#include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/media/filtering_file_enumerator.h"
 #include "webkit/fileapi/media/media_file_system_mount_point_provider.h"
 #include "webkit/fileapi/media/media_path_filter.h"
 #include "webkit/fileapi/media/mtp_device_async_delegate.h"
 #include "webkit/fileapi/media/mtp_device_map_service.h"
 
+using webkit_blob::ShareableFileReference;
+
 namespace fileapi {
 
 namespace {
 
 const base::FilePath::CharType kDeviceMediaAsyncFileUtilTempDir[] =
     FILE_PATH_LITERAL("DeviceMediaFileSystem");
 
 // Returns true if the current thread is IO thread.
 bool IsOnIOThread(FileSystemOperationContext* context) {
   return context->file_system_context()->task_runners()->
@@ skipping 268 matching lines @@
 
 void DeviceMediaAsyncFileUtil::OnReadDirectoryError(
     const AsyncFileUtil::ReadDirectoryCallback& callback,
     base::PlatformFileError error) {
   if (!callback.is_null())
     callback.Run(error, AsyncFileUtil::EntryList(), false /*no more*/);
 }
 
 void DeviceMediaAsyncFileUtil::OnDidCreateSnapshotFile(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
+    base::SequencedTaskRunner* media_task_runner,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path) {
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_OK, file_info, platform_path,
-                 kSnapshotFileTemporary);
+  if (callback.is_null())
+    return;
+  callback.Run(base::PLATFORM_FILE_OK, file_info, platform_path,
+               ShareableFileReference::GetOrCreate(
+                   platform_path,
+                   ShareableFileReference::DELETE_ON_FINAL_RELEASE,
+                   media_task_runner));
 }
 
 void DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError(
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     base::PlatformFileError error) {
   if (!callback.is_null())
     callback.Run(error, base::PlatformFileInfo(), base::FilePath(),
-                 kSnapshotFileTemporary);
+                 scoped_refptr<ShareableFileReference>());
 }
 
 void DeviceMediaAsyncFileUtil::OnSnapshotFileCreatedRunTask(
     FileSystemOperationContext* context,
     const AsyncFileUtil::CreateSnapshotFileCallback& callback,
     const base::FilePath& device_file_path,
     base::FilePath* snapshot_file_path) {
   DCHECK(IsOnIOThread(context));
   if (!snapshot_file_path || snapshot_file_path->empty()) {
     OnCreateSnapshotFileError(callback, base::PLATFORM_FILE_ERROR_FAILED);
     return;
   }
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(context);
   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),
+                 callback,
+                 make_scoped_refptr(context->task_runner())),
       base::Bind(&DeviceMediaAsyncFileUtil::OnCreateSnapshotFileError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 }  // namespace fileapi