[FileAPI] Add file open ID and close callback

webkit/fileapi/local_file_system_operation.cc

 // 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.
 
 #include "webkit/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 15 matching lines @@
 #include "webkit/fileapi/remove_operation_delegate.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 using webkit_blob::ScopedFile;
 using webkit_blob::ShareableFileReference;
 
 namespace fileapi {
 
+namespace {
+void NopCloseFileCallback() {}
+}
+
 LocalFileSystemOperation::LocalFileSystemOperation(
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context)
     : file_system_context_(file_system_context),
       operation_context_(operation_context.Pass()),
       async_file_util_(NULL),
       peer_handle_(base::kNullProcessHandle),
       pending_operation_(kOperationNone),
       weak_factory_(this) {
   DCHECK(operation_context_.get());
@@ skipping 280 matching lines @@
   DCHECK(SetPendingOperationType(kOperationOpenFile));
   scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
+                 base::Closure(),
                  base::kNullProcessHandle);
     return;
   }
   if (file_flags &
       (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_OPEN_ALWAYS |
        base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_TRUNCATED |
        base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
        base::PLATFORM_FILE_DELETE_ON_CLOSE |
        base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
     base::PlatformFileError result = SetUp(url, OPERATION_MODE_WRITE);
     if (result != base::PLATFORM_FILE_OK) {
       callback.Run(result,
                    base::kInvalidPlatformFileValue,
+                   base::Closure(),
                    base::kNullProcessHandle);
       return;
     }
   } else {
     base::PlatformFileError result = SetUp(url, OPERATION_MODE_READ);
     if (result != base::PLATFORM_FILE_OK) {
       callback.Run(result,
                    base::kInvalidPlatformFileValue,
+                   base::Closure(),
                    base::kNullProcessHandle);
       return;
     }
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoOpenFile,
                  base::Unretained(deleter.release()),
                  url, callback, file_flags),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
+                 base::Closure(),
                  base::kNullProcessHandle));
 }
 
 void LocalFileSystemOperation::NotifyCloseFile(const FileSystemURL& url) {
   // No particular task to do. This method is for remote file systems that
   // need synchronization with remote server.
   delete this;
 }
 
 // We can only get here on a write or truncate that's not yet completed.
@@ skipping 440 matching lines @@
   callback.Run(rv);
 }
 
 void LocalFileSystemOperation::DidOpenFile(
     const OpenFileCallback& callback,
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool unused) {
   if (rv == base::PLATFORM_FILE_OK)
     CHECK_NE(base::kNullProcessHandle, peer_handle_);
-  callback.Run(rv, file.ReleaseValue(), peer_handle_);
+  callback.Run(rv, file.ReleaseValue(),
+               base::Bind(&NopCloseFileCallback),
+               peer_handle_);
 }
 
 void LocalFileSystemOperation::DidCreateSnapshotFile(
     const SnapshotFileCallback& callback,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<ShareableFileReference>& file_ref) {
   callback.Run(result, file_info, platform_path, file_ref);
 }
@@ skipping 29 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi