Remove CloseFile from FileSystem.

chrome/browser/chromeos/drive/fileapi_worker.cc

 // Copyright 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/chromeos/drive/fileapi_worker.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 118 matching lines @@
       webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT :
       webkit_blob::ScopedFile::DONT_DELETE_ON_SCOPE_OUT;
 
   callback.Run(base::PLATFORM_FILE_OK, file_info, local_path, scope_out_policy);
 }
 
 // Runs |callback| with arguments converted from |error| and |local_path|.
 void RunCreateWritableSnapshotFileCallback(
     const CreateWritableSnapshotFileCallback& callback,
     FileError error,
-    const base::FilePath& local_path) {
+    const base::FilePath& local_path,
+    const base::Closure& on_close_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  callback.Run(FileErrorToPlatformError(error), local_path);
+  callback.Run(FileErrorToPlatformError(error), local_path, on_close_callback);
 }
 
 // Runs |callback| with |error| and |platform_file|.
 void RunOpenFileCallback(const OpenFileCallback& callback,
+                         const base::Closure& on_close_callback,
                          base::PlatformFileError* error,
                          base::PlatformFile platform_file) {
-  callback.Run(*error, platform_file);
+  callback.Run(*error, platform_file, on_close_callback);
 }
 
 // Part of OpenFile(). Called after FileSystem::OpenFile().
 void OpenFileAfterFileSystemOpenFile(int file_flags,
                                      const OpenFileCallback& callback,
                                      FileError error,
-                                     const base::FilePath& local_path) {
+                                     const base::FilePath& local_path,
+                                     const base::Closure& on_close_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToPlatformError(error),
-                 base::kInvalidPlatformFileValue);
+                 base::kInvalidPlatformFileValue,
+                 base::Closure());
     return;
   }
 
   // Here, the file should be at |local_path|, but there may be timing issue.
   // Because the file is managed by Drive file system, so, in order to avoid
   // unexpected file creation, CREATE, OPEN_ALWAYS and CREATE_ALWAYS are
   // translated into OPEN or OPEN_TRUNCATED, here. Keep OPEN and OPEN_TRUNCATED
   // as is.
   if (file_flags & (base::PLATFORM_FILE_CREATE |
                     base::PLATFORM_FILE_OPEN_ALWAYS)) {
     file_flags &= ~(base::PLATFORM_FILE_CREATE |
                     base::PLATFORM_FILE_OPEN_ALWAYS);
     file_flags |= base::PLATFORM_FILE_OPEN;
   } else if (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS) {
     file_flags &= ~base::PLATFORM_FILE_CREATE_ALWAYS;
     file_flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
   }
 
   // Cache file prepared for modification is available. Open it locally.
   base::PlatformFileError* result =
       new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
   bool posted = base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&base::CreatePlatformFile,
                  local_path, file_flags, static_cast<bool*>(NULL), result),
-      base::Bind(&RunOpenFileCallback, callback, base::Owned(result)));
+      base::Bind(&RunOpenFileCallback,
+                 callback, on_close_callback, base::Owned(result)));
   DCHECK(posted);
 }
 
-// Emits debug log when FileSystem::CloseFile() is complete.
-void EmitDebugLogForCloseFile(const base::FilePath& local_path,
-                              FileError file_error) {
-  DVLOG(1) << "Closed: " << local_path.AsUTF8Unsafe() << ": " << file_error;
-}
-
 }  // namespace
 
 void RunFileSystemCallback(
     const FileSystemGetter& file_system_getter,
     const base::Callback<void(FileSystemInterface*)>& callback,
     const base::Closure& on_error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FileSystemInterface* file_system = file_system_getter.Run();
 
   if (!file_system) {
@@ skipping 123 matching lines @@
                      base::PLATFORM_FILE_CREATE_ALWAYS |
                      base::PLATFORM_FILE_OPEN_TRUNCATED |
                      base::PLATFORM_FILE_READ |
                      base::PLATFORM_FILE_WRITE |
                      base::PLATFORM_FILE_WRITE_ATTRIBUTES |
                      base::PLATFORM_FILE_APPEND)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_FAILED,
-                   base::kInvalidPlatformFileValue));
+                   base::kInvalidPlatformFileValue,
+                   base::Closure()));
     return;
   }
 
   file_system->OpenFile(
       file_path, GetOpenMode(file_flags),
       base::Bind(&OpenFileAfterFileSystemOpenFile, file_flags, callback));
 }
 
-void CloseFile(const base::FilePath& file_path,
-               FileSystemInterface* file_system) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  file_system->CloseFile(file_path,
-                         base::Bind(&EmitDebugLogForCloseFile, file_path));
-}
-
 void TouchFile(const base::FilePath& file_path,
                const base::Time& last_access_time,
                const base::Time& last_modified_time,
                const StatusCallback& callback,
                FileSystemInterface* file_system) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   file_system->TouchFile(file_path, last_access_time, last_modified_time,
                          base::Bind(&RunStatusCallbackByFileError, callback));
 
 }
 
 }  // namespace fileapi_internal
 }  // namespace drive