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

webkit/fileapi/async_file_util.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_ASYNC_FILE_UTIL_H_
 #define WEBKIT_FILEAPI_ASYNC_FILE_UTIL_H_
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/files/file_util_proxy.h"
 #include "base/platform_file.h"
-#include "webkit/fileapi/file_snapshot_policy.h"
 #include "webkit/storage/webkit_storage_export.h"
 
 namespace base {
 class Time;
 }
 
+namespace webkit_blob {
+class ShareableFileReference;
+}
+
 namespace fileapi {
 
 class FileSystemOperationContext;
 class FileSystemURL;
 
 // An interface which provides filesystem-specific file operations for
 // LocalFileSystemOperation.
 //
 // Each filesystem which needs to be dispatched from LocalFileSystemOperation
 // must implement this interface or a synchronous version of interface:
@@ skipping 19 matching lines @@
   typedef std::vector<base::FileUtilProxy::Entry> EntryList;
   typedef base::Callback<
       void(base::PlatformFileError result,
            const EntryList& file_list,
            bool has_more)> ReadDirectoryCallback;
 
   typedef base::Callback<
       void(base::PlatformFileError result,
            const base::PlatformFileInfo& file_info,
            const base::FilePath& platform_path,
-           SnapshotFilePolicy policy)> CreateSnapshotFileCallback;
+           const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref
+           )> CreateSnapshotFileCallback;
 
   AsyncFileUtil() {}
   virtual ~AsyncFileUtil() {}
 
   // Creates or opens a file with the given flags.
   // If PLATFORM_FILE_CREATE is set in |file_flags| it always tries to create
   // a new file at the given |url| and calls back with
   // PLATFORM_FILE_ERROR_FILE_EXISTS if the |url| already exists.
   //
   // LocalFileSystemOperation::OpenFile calls this.
@@ skipping 213 matching lines @@
   // metadata and platform path of the snapshot file via |callback|.
   // In regular filesystem cases the implementation may simply return
   // the metadata of the file itself (as well as GetMetadata does),
   // while in non-regular filesystem case the backend may create a
   // temporary snapshot file which holds the file data and return
   // the metadata of the temporary file.
   //
   // In the callback, it returns:
   // |file_info| is the metadata of the snapshot file created.
   // |platform_path| is the path to the snapshot file created.
-  // |policy| should indicate the policy how the fileapi backend
-  // should handle the returned file.
+  //
+  // If implementors creates a temporary file for snapshotting and wants
+  // FileAPI backend to take care of the lifetime of the file (so that
+  // it won't get deleted while JS layer has any references to the created
+  // File/Blob object), it should return non-empty |file_ref|.
+  // Via the |file_ref| implementors can schedule a file deletion
+  // or arbitrary callbacks when the last reference of File/Blob is dropped.
   //
   // LocalFileSystemOperation::CreateSnapshotFile calls this.
   //
   // This returns false if it fails to post an async task.
   //
   // This reports following error code via |callback|:
   // - PLATFORM_FILE_ERROR_NOT_FOUND if |url| does not exist.
   // - PLATFORM_FILE_ERROR_NOT_A_FILE if |url| exists but is a directory.
   //
   // The field values of |file_info| are undefined (implementation
   // dependent) in error cases, and the caller should always
   // check the return code.
   virtual bool CreateSnapshotFile(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       const CreateSnapshotFileCallback& callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsyncFileUtil);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_ASYNC_FILE_UTIL_H_