Support creating temporary files for sync file operations.

base/file_util_proxy.h

 // 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.
 
 #ifndef BASE_FILE_UTIL_PROXY_H_
 #define BASE_FILE_UTIL_PROXY_H_
 
 #include <vector>
 
 #include "base/base_api.h"
@@ skipping 46 matching lines @@
   // for the callback.
   // If PLATFORM_FILE_CREATE is set in |file_flags| it always tries to create
   // a new file at the given |file_path| and calls back with
   // PLATFORM_FILE_ERROR_FILE_EXISTS if the |file_path| already exists.
   static bool CreateOrOpen(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                            const FilePath& file_path,
                            int file_flags,
                            CreateOrOpenCallback* callback);
 
   // Creates a temporary file for writing.  The path and an open file handle
-  // are returned.  It is invalid to pass NULL for the callback.
+  // are returned.  It is invalid to pass NULL for the callback.  The file
+  // flags should at least set base::PLATFORM_FILE_TEMPORARY and
+  // base::PLATFORM_FILE_WRITE and some flag related to the temporary file
+  // creation.  A typical example would be:
+  //   base::PLATFORM_FILE_CREATE_ALWAYS |

[darin (slow to review), 2011/06/04 21:06:01]

i think having to specify PLATFORM_FILE_TEMPORARY makes the API redundant.  the
method name is CreateTemporary after all!

how about we rename file_flags to additional_file_flags (or
optional_file_flags), and then we document that CREATE_ALWAYS, WRITE, and
TEMPORARY bits comprise the default file flags.  this way the callers can pass 0
if they don't need to specify anything special.

so i would expect to see CreateTemporary(loop, 0, callback) in many cases or
CreateTemporary(loop, PLATFORM_FILE_ASYNC, callback) in cases where we want to
open the file for async IO.

finally, it occurs to me that fixing this method to make it possible to not set
PLATFORM_FILE_ASYNC doesn't really fix the original issue you were trying to
solve.  the problem you had was that the Write method cannot handle a
PlatformFile that was opened with PLATFORM_FILE_ASYNC.  maybe we should look
into modifying the Write function to support that mode as well?

[Sam Kerner (Chrome), 2011/06/06 22:19:27]

I looked in to doing this a while ago, and I think I added a TODO around the
Write method.  If you want to do this, I can point you to the docs and show you
a unit test that can exercise it.

+  //   base::PLATFORM_FILE_WRITE |
+  //   base::PLATFORM_FILE_TEMPORARY
+  // for synchronous writes.  Add base::PLATFORM_FILE_ASYNC to support
+  // asynchronous file operations for net::FileStream.
   static bool CreateTemporary(
       scoped_refptr<MessageLoopProxy> message_loop_proxy,
+      int file_flags,
       CreateTemporaryCallback* callback);
 
   // Close the given file handle.
   static bool Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                     PlatformFile,
                     StatusCallback* callback);
 
   // Ensures that the given |file_path| exist.  This creates a empty new file
   // at |file_path| if the |file_path| does not exist.
   // If a new file han not existed and is created at the |file_path|,
@@ skipping 127 matching lines @@
       PlatformFile file,
       StatusCallback* callback);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileUtilProxy);
 };
 
 }  // namespace base
 
 #endif  // BASE_FILE_UTIL_PROXY_H_