Support creating temporary files for sync file operations.

base/file_util_proxy.cc

 // Copyright (c) 2011 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 "base/file_util_proxy.h"
 
 #include "base/message_loop_proxy.h"
+#include "base/platform_file.h"
 
 // TODO(jianli): Move the code from anonymous namespace to base namespace so
 // that all of the base:: prefixes would be unnecessary.
 namespace {
 
 namespace {
 
 // Performs common checks for move and copy.
 // This also removes the destination directory if it's non-empty and all other
 // checks are passed (so that the copy/move correctly overwrites the
@@ skipping 142 matching lines @@
   int file_flags_;
   base::FileUtilProxy::CreateOrOpenCallback* callback_;
   base::PlatformFile file_handle_;
   bool created_;
 };
 
 class RelayCreateTemporary : public MessageLoopRelay {
  public:
   RelayCreateTemporary(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+      int file_flags,
       base::FileUtilProxy::CreateTemporaryCallback* callback)
       : message_loop_proxy_(message_loop_proxy),
+        file_flags_(file_flags),
         callback_(callback),
         file_handle_(base::kInvalidPlatformFileValue) {
     DCHECK(callback);
   }
 
  protected:
   virtual ~RelayCreateTemporary() {
     if (file_handle_ != base::kInvalidPlatformFileValue)
       base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     // TODO(darin): file_util should have a variant of CreateTemporaryFile
     // that returns a FilePath and a PlatformFile.
     file_util::CreateTemporaryFile(&file_path_);
 
-    // Use a fixed set of flags that are appropriate for writing to a temporary
-    // file from the IO thread using a net::FileStream.
-    int file_flags =
-        base::PLATFORM_FILE_CREATE_ALWAYS |
-        base::PLATFORM_FILE_WRITE |
-        base::PLATFORM_FILE_ASYNC |
-        base::PLATFORM_FILE_TEMPORARY;
+    if (!(file_flags_ & base::PLATFORM_FILE_WRITE) ||
+        !(file_flags_ & base::PLATFORM_FILE_TEMPORARY) ||
+        (!(file_flags_ & base::PLATFORM_FILE_CREATE_ALWAYS) &&
+         !(file_flags_ & base::PLATFORM_FILE_CREATE) &&
+         !(file_flags_ & base::PLATFORM_FILE_OPEN_ALWAYS))) {
+      LOG(DFATAL) << "Invalid file_flags for CreateTemporary: " << file_flags_;
+      set_error_code(base::PLATFORM_FILE_ERROR_FAILED);
+      return;
+    }
     base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
-    file_handle_ = base::CreatePlatformFile(file_path_, file_flags,
+    file_handle_ = base::CreatePlatformFile(file_path_, file_flags_,
                                             NULL, &error_code);
     set_error_code(error_code);
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), base::PassPlatformFile(&file_handle_),
                    file_path_);
     delete callback_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  int file_flags_;
   base::FileUtilProxy::CreateTemporaryCallback* callback_;
   base::PlatformFile file_handle_;
   FilePath file_path_;
 };
 
 class RelayWithStatusCallback : public MessageLoopRelay {
  public:
   explicit RelayWithStatusCallback(
       base::FileUtilProxy::StatusCallback* callback)
       : callback_(callback) {
@@ skipping 516 matching lines @@
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path, int file_flags,
     CreateOrOpenCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(
       message_loop_proxy, file_path, file_flags, callback));
 }
 
 // static
 bool FileUtilProxy::CreateTemporary(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
+    int file_flags,
     CreateTemporaryCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
-               new RelayCreateTemporary(message_loop_proxy, callback));
+               new RelayCreateTemporary(message_loop_proxy,
+                                        file_flags,
+                                        callback));
 }
 
 // static
 bool FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                           base::PlatformFile file_handle,
                           StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayClose(file_handle, callback));
 }
 
@@ skipping 150 matching lines @@
 
 // static
 bool FileUtilProxy::Flush(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayFlush(file, callback));
 }
 
 }  // namespace base