Remove PlatformFile from fileapi::FileSystemFileUtil

webkit/browser/fileapi/obfuscated_file_util.h

 // Copyright (c) 2012 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_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 #define WEBKIT_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util_proxy.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/sandbox_directory_database.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ skipping 76 matching lines @@
       quota::SpecialStoragePolicy* special_storage_policy,
       const base::FilePath& file_system_directory,
       leveldb::Env* env_override,
       base::SequencedTaskRunner* file_task_runner,
       const GetTypeStringForURLCallback& get_type_string_for_url,
       const std::set<std::string>& known_type_strings,
       SandboxFileSystemBackendDelegate* sandbox_delegate);
   virtual ~ObfuscatedFileUtil();
 
   // FileSystemFileUtil overrides.
-  virtual base::File::Error CreateOrOpen(
+  virtual base::File CreateOrOpen(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      int file_flags,
-      base::PlatformFile* file_handle,
-      bool* created) OVERRIDE;
-  virtual base::File::Error Close(
-      FileSystemOperationContext* context,
-      base::PlatformFile file) OVERRIDE;
+      int file_flags) OVERRIDE;
   virtual base::File::Error EnsureFileExists(
       FileSystemOperationContext* context,
       const FileSystemURL& url, bool* created) OVERRIDE;
   virtual base::File::Error CreateDirectory(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       bool exclusive,
       bool recursive) OVERRIDE;
   virtual base::File::Error GetFileInfo(
       FileSystemOperationContext* context,
@@ skipping 123 matching lines @@
 
   base::File::Error GetFileInfoInternal(
       SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       FileId file_id,
       FileInfo* local_info,
       base::File::Info* file_info,
       base::FilePath* platform_file_path);
 
+  base::File::Error GetDbRootAndLocalPath(
+    FileSystemOperationContext* context,
+    const FileSystemURL& dest_url,
+    SandboxDirectoryDatabase** db,
+    base::FilePath* root,
+    base::FilePath* local_path);
+
+  // Updates |dest_file_info| and |db| at the end of creating a new file.
+  base::File::Error PostCreateFile(
+    const base::FilePath& root,
+    const base::FilePath& local_path,
+    FileInfo* dest_file_info,
+    SandboxDirectoryDatabase* db);

[kinuko, 2014/05/12 05:39:57]

nit: could we move these methods declarations/definitions after
Create{,AndOpen}File?

[rvargas (doing something else), 2014/05/12 23:39:59]

Done.

+
   // Creates a new file, both the underlying backing file and the entry in the
   // database.  |dest_file_info| is an in-out parameter.  Supply the name and
   // parent_id; data_path is ignored.  On success, data_path will
   // always be set to the relative path [from the root of the type-specific
-  // filesystem directory] of a NEW backing file, and handle, if supplied, will
-  // hold open PlatformFile for the backing file, which the caller is
-  // responsible for closing.  If you supply a path in |source_path|, it will be
-  // used as a source from which to COPY data.
-  // Caveat: do not supply handle if you're also supplying a data path.  It was
-  // easier not to support this, and no code has needed it so far, so it will
-  // DCHECK and handle will hold base::kInvalidPlatformFileValue.
+  // filesystem directory] of a NEW backing file.  Returns the new file.
+  base::File CreateAndOpenFile(
+      FileSystemOperationContext* context,
+      const FileSystemURL& dest_url,
+      FileInfo* dest_file_info,
+      int file_flags);
+
+  // The same as CreateAndOpenFile except that a file is not returned and if a
+  // path is provided in |source_path|, it will be used as a source from which
+  // to COPY data.
   base::File::Error CreateFile(
       FileSystemOperationContext* context,
       const base::FilePath& source_file_path,
       const FileSystemURL& dest_url,
-      FileInfo* dest_file_info,
-      int file_flags,
-      base::PlatformFile* handle);
+      FileInfo* dest_file_info);
 
   // This converts from a relative path [as is stored in the FileInfo.data_path
   // field] to an absolute platform path that can be given to the native
   // filesystem.
   base::FilePath DataPathToLocalPath(
       const FileSystemURL& url,
       const base::FilePath& data_file_path);
 
   std::string GetDirectoryDatabaseKey(const GURL& origin,
                                       const std::string& type_string);
@@ skipping 20 matching lines @@
   // Initializes the origin database. |origin_hint| may be used as a hint
   // for initializing database if it's not empty.
   bool InitOriginDatabase(const GURL& origin_hint, bool create);
 
   base::File::Error GenerateNewLocalPath(
       SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       base::FilePath* local_path);
 
-  base::File::Error CreateOrOpenInternal(
+  base::File CreateOrOpenInternal(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
-      int file_flags,
-      base::PlatformFile* file_handle,
-      bool* created);
+      int file_flags);
 
   bool HasIsolatedStorage(const GURL& origin);
 
   typedef std::map<std::string, SandboxDirectoryDatabase*> DirectoryMap;
   DirectoryMap directories_;
   scoped_ptr<SandboxOriginDatabaseInterface> origin_database_;
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   base::FilePath file_system_directory_;
   leveldb::Env* env_override_;
 
   // Used to delete database after a certain period of inactivity.
   int64 db_flush_delay_seconds_;
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
   scoped_ptr<TimedTaskHelper> timer_;
 
   GetTypeStringForURLCallback get_type_string_for_url_;
   std::set<std::string> known_type_strings_;
 
   // Not owned.
   SandboxFileSystemBackendDelegate* sandbox_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_OBFUSCATED_FILE_UTIL_H_