Rename FileUtilProxy::Create to EnsureFileExists

webkit/fileapi/file_system_operation.cc

 // Copyright (c) 2010 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/file_system_operation.h"
 
 #include "base/time.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_writer_delegate.h"
@@ skipping 18 matching lines @@
     base::FileUtilProxy::Close(proxy_, file_writer_delegate_->file(), NULL);
 }
 
 void FileSystemOperation::CreateFile(const FilePath& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
 
-  base::FileUtilProxy::Create(
-    proxy_, path, base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
-    callback_factory_.NewCallback(
-        exclusive ? &FileSystemOperation::DidCreateFileExclusive
-                  : &FileSystemOperation::DidCreateFileNonExclusive));
+  base::FileUtilProxy::EnsureFileExists(
+    proxy_, path, callback_factory_.NewCallback(
+        exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
+                  : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
 }
 
 void FileSystemOperation::CreateDirectory(const FilePath& path,
                                           bool exclusive,
                                           bool recursive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
 
@@ skipping 158 matching lines @@
     DCHECK(kOperationTruncate == pending_operation_);
 #endif
     // We're cancelling a truncate operation, but we can't actually stop it
     // since it's been proxied to another thread.  We need to save the
     // cancel_operation so that when the truncate returns, it can see that it's
     // been cancelled, report it, and report that the cancel has succeeded.
     cancel_operation_ = cancel_operation;
   }
 }
 
-void FileSystemOperation::DidCreateFileExclusive(
-    base::PlatformFileError rv,
-    base::PassPlatformFile file,
-    bool created) {
+void FileSystemOperation::DidEnsureFileExistsExclusive(
+    base::PlatformFileError rv, bool created) {
+  if (rv == base::PLATFORM_FILE_OK && !created)
+    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
+  else
+    DidFinishFileOperation(rv);
+}
+
+void FileSystemOperation::DidEnsureFileExistsNonExclusive(
+    base::PlatformFileError rv, bool /* created */) {
   DidFinishFileOperation(rv);
 }
 
-void FileSystemOperation::DidCreateFileNonExclusive(
-    base::PlatformFileError rv,
-    base::PassPlatformFile file,
-    bool created) {
-  // Suppress the already exists error and report success.
-  if (rv == base::PLATFORM_FILE_OK ||
-      rv == base::PLATFORM_FILE_ERROR_EXISTS)
-    dispatcher_->DidSucceed();
-  else
-    dispatcher_->DidFail(rv);
-}
-
 void FileSystemOperation::DidFinishFileOperation(
     base::PlatformFileError rv) {
   if (cancel_operation_) {
 #ifndef NDEBUG
     DCHECK(kOperationTruncate == pending_operation_);
 #endif
     FileSystemOperation *cancel_op = cancel_operation_;
     // This call deletes us, so we have to extract cancel_op first.
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
     cancel_op->dispatcher_->DidSucceed();
@@ skipping 57 matching lines @@
 }
 
 void FileSystemOperation::DidTouchFile(base::PlatformFileError rv) {
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidSucceed();
   else
     dispatcher_->DidFail(rv);
 }
 
 }  // namespace fileapi