Remove CloseFile from FileSystem.

chrome/browser/chromeos/drive/file_system_interface.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 CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_INTERFACE_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_INTERFACE_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 80 matching lines @@
     scoped_ptr<std::vector<SearchResultInfo> > result_paths)> SearchCallback;
 
 // Callback for SearchMetadata(). On success, |error| is FILE_ERROR_OK, and
 // |result| contains the search result.
 typedef base::Callback<void(
     FileError error,
     scoped_ptr<MetadataSearchResultVector> result)> SearchMetadataCallback;
 
 // Used to open files from the file system. |file_path| is the path on the local
 // file system for the opened file.
+// If |on_close_callback| is not null, it must be called when the
+// modification to the cache is done. Otherwise, Drive file system does not
+// pick up the file for uploading.
+// |on_close_callback| must not be called more than once.
 typedef base::Callback<void(FileError error,
-                            const base::FilePath& file_path)> OpenFileCallback;
+                            const base::FilePath& file_path,
+                            const base::Closure& on_close_callback)>

[hashimoto, 2013/07/24 03:43:57]

nit: Why is this callback called "on close callback"?  I feel "close callback"
sounds better because this callback is not called after the file gets closed,
but when the user code wants to close the file.

[hidehiko, 2013/07/24 04:49:45]

Done.

+    OpenFileCallback;
 
 // Used to get available space for the account from Drive.
 typedef base::Callback<void(FileError error,
                             int64 bytes_total,
                             int64 bytes_used)> GetAvailableSpaceCallback;
 
 // Used to get filesystem metadata.
 typedef base::Callback<void(const FileSystemMetadata&)>
     GetFilesystemMetadataCallback;
 
+// Used to mark cached files mounted.
+typedef base::Callback<void(FileError error,
+                            const base::FilePath& file_path)>
+    MarkMountedCallback;
+
 // The mode of opening a file.
 enum OpenMode {
   // Open the file if exists. If not, failed.
   OPEN_FILE,
 
   // Create a new file if not exists, and then open it. If exists, failed.
   CREATE_FILE,
 
   // Open the file if exists. If not, create a new file and then open it.
   OPEN_OR_CREATE_FILE,
@@ skipping 63 matching lines @@
   virtual void TransferFileFromLocalToRemote(
       const base::FilePath& local_src_file_path,
       const base::FilePath& remote_dest_file_path,
       const FileOperationCallback& callback) = 0;
 
   // Retrieves a file at the virtual path |file_path| on the Drive file system
   // onto the cache, and mark it dirty. The local path to the cache file is
   // returned to |callback|. After opening the file, both read and write
   // on the file can be done with normal local file operations.
   //
-  // |CloseFile| must be called when the modification to the cache is done.
-  // Otherwise, Drive file system does not pick up the file for uploading.
-  //
   // |callback| must not be null.
   virtual void OpenFile(const base::FilePath& file_path,
                         OpenMode open_mode,
                         const OpenFileCallback& callback) = 0;
 
-  // Closes a file at the virtual path |file_path| on the Drive file system,
-  // which is opened via OpenFile(). It commits the dirty flag on the cache.
-  //
-  // |callback| must not be null.
-  virtual void CloseFile(const base::FilePath& file_path,
-                         const FileOperationCallback& callback) = 0;
-
   // Copies |src_file_path| to |dest_file_path| on the file system.
   // |src_file_path| can be a hosted document (see limitations below).
   // |dest_file_path| is expected to be of the same type of |src_file_path|
   // (i.e. if |src_file_path| is a file, |dest_file_path| will be created as
   // a file).
   //
   // This method also has the following assumptions/limitations that may be
   // relaxed or addressed later:
   // - |src_file_path| cannot be a regular file (i.e. non-hosted document)
   //   or a directory.
@@ skipping 162 matching lines @@
 
   // Returns miscellaneous metadata of the file system like the largest
   // timestamp. Used in chrome:drive-internals. |callback| must not be null.
   virtual void GetMetadata(
       const GetFilesystemMetadataCallback& callback) = 0;
 
   // Marks the cached file as mounted, and runs |callback| upon completion.
   // If succeeded, the cached file path will be passed to the |callback|.
   // |callback| must not be null.
   virtual void MarkCacheFileAsMounted(const base::FilePath& drive_file_path,
-                                    const OpenFileCallback& callback) = 0;
+                                      const MarkMountedCallback& callback) = 0;
 
   // Marks the cached file as unmounted, and runs |callback| upon completion.
   // Note that this method expects that the |cached_file_path| is the path
   // returned by MarkCacheFileAsMounted().
   // |callback| must not be null.
   virtual void MarkCacheFileAsUnmounted(
       const base::FilePath& cache_file_path,
       const FileOperationCallback& callback) = 0;
 
   // Gets the cache entry for file corresponding to |resource_id| and |md5|
   // and runs |callback| with true and the found entry if the entry exists
   // in the cache map. Otherwise, runs |callback| with false.
   // |md5| can be empty if only matching |resource_id| is desired.
   // |callback| must not be null.
   virtual void GetCacheEntryByResourceId(
       const std::string& resource_id,
       const std::string& md5,
       const GetCacheEntryCallback& callback) = 0;
 
   // Reloads the resource metadata from the server.
   virtual void Reload() = 0;
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILE_SYSTEM_INTERFACE_H_