Add CreateTemporaryFile to PPB_Flash_File_ModuleLocal.

ppapi/c/private/ppb_flash_file.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 PPAPI_C_PRIVATE_PPB_FLASH_FILE_H_
 #define PPAPI_C_PRIVATE_PPB_FLASH_FILE_H_
 
 #ifdef _WIN32
 #include <windows.h>
 #endif
@@ skipping 16 matching lines @@
   const char* name;
   PP_Bool is_dir;
 };
 
 struct PP_DirContents_Dev {
   int32_t count;
   struct PP_DirEntry_Dev* entries;
 };
 
 // PPB_Flash_File_ModuleLocal --------------------------------------------------
-
-#define PPB_FLASH_FILE_MODULELOCAL_INTERFACE "PPB_Flash_File_ModuleLocal;2"
+#define PPB_FLASH_FILE_MODULELOCAL_INTERFACE_2_0 "PPB_Flash_File_ModuleLocal;2"
+#define PPB_FLASH_FILE_MODULELOCAL_INTERFACE_3_0 "PPB_Flash_File_ModuleLocal;3"
+#define PPB_FLASH_FILE_MODULELOCAL_INTERFACE \
+    PPB_FLASH_FILE_MODULELOCAL_INTERFACE_3_0
 
 // This interface provides (for Flash) synchronous access to module-local files.
 // Module-local file paths are '/'-separated UTF-8 strings, relative to a
 // module-specific root.
-struct PPB_Flash_File_ModuleLocal {
+struct PPB_Flash_File_ModuleLocal_3_0 {
   // Does initialization necessary for proxying this interface on background
   // threads. You must always call this function before using any other
   // function in this interface for a given instance ID.
   //
   // Returns true if multithreaded access is supported. In this case you can
   // use the rest of the functions from background threads. You may not call
   // GetInterface or do any other PPAPI operations on background threads at
   // this time.
   bool (*CreateThreadAdapterForInstance)(PP_Instance instance);
 
@@ skipping 36 matching lines @@
   // Gets the list of files contained in a directory. The return value is the
   // ppapi error, PP_OK if success, one of the PP_ERROR_* in case of failure. If
   // non-NULL, the returned contents should be freed with FreeDirContents.
   int32_t (*GetDirContents)(PP_Instance instance,
                             const char* path,
                             struct PP_DirContents_Dev** contents);
 
   // Frees the data allocated by GetDirContents.
   void (*FreeDirContents)(PP_Instance instance,
                           struct PP_DirContents_Dev* contents);
+
+  // Creates a temporary file in the directory specified by |dir_path|. The file
+  // will be automatically deleted when all handles to it are closed.
+  // Returns PP_OK if successful, one of the PP_ERROR_* values in case of
+  // failure.
+  //
+  // If successful, |file| is set to a file descriptor (posix) or a HANDLE
+  // (win32) to the file; |file_name_buffer| is set to the resulting file name
+  // (NULL-terminated). If failed, neither |file| nor |file_name_buffer| is
+  // touched.
+  // If |file_name_buffer| is too small to store the resulting file name plus
+  // the trailing NULL, the method fails and returns PP_ERROR_NOMEMORY.
+  int32_t (*CreateTemporaryFile)(PP_Instance instance,

[viettrungluu, 2012/06/07 20:17:36]

Why don't we just add this to OpenFile()'s functionality? We could presumably
add a flag to |mode| and a note that for the temporary-file case |path| means
the directory path. Also, I don't see a good reason for returning the file name
-- it's typically meaningless on POSIX-ish systems, where temporary files are
created by making a file (with whatever name) and then unlink()ing it
immediately.

[yzshen1, 2012/06/07 21:42:06]

I considered adding this to OpenFile(), but I didn't do it that way because:
- We cannot easily add new flag to PP_FileOpenFlags, which is an official enum.
- The different meaning of |path| seems significant to me to justify a new
method.
- If we would like to return the resulting file name, it would be a good reason
to have a new method as well. I took a look at the file system API in Flash, it
has a method to get file name.

+                                 const char* dir_path,
+                                 PP_FileHandle* file,
+                                 char* file_name_buffer,
+                                 uint32_t file_name_buffer_size);
+};
+
+struct PPB_Flash_File_ModuleLocal_2_0 {
+  bool (*CreateThreadAdapterForInstance)(PP_Instance instance);
+  void (*ClearThreadAdapterForInstance)(PP_Instance instance);
+  int32_t (*OpenFile)(PP_Instance instance,
+                      const char* path,
+                      int32_t mode,
+                      PP_FileHandle* file);
+  int32_t (*RenameFile)(PP_Instance instance,
+                        const char* path_from,
+                        const char* path_to);
+  int32_t (*DeleteFileOrDir)(PP_Instance instance,
+                             const char* path,
+                             PP_Bool recursive);
+  int32_t (*CreateDir)(PP_Instance instance, const char* path);
+  int32_t (*QueryFile)(PP_Instance instance,
+                       const char* path,
+                       struct PP_FileInfo* info);
+  int32_t (*GetDirContents)(PP_Instance instance,
+                            const char* path,
+                            struct PP_DirContents_Dev** contents);
+  void (*FreeDirContents)(PP_Instance instance,
+                          struct PP_DirContents_Dev* contents);
 };
 
+typedef struct PPB_Flash_File_ModuleLocal_3_0 PPB_Flash_File_ModuleLocal;
+
 // PPB_Flash_File_FileRef ------------------------------------------------------
 
 #define PPB_FLASH_FILE_FILEREF_INTERFACE "PPB_Flash_File_FileRef;2"
 
 // This interface provides (for Flash) synchronous access to files whose paths
 // are given by a Pepper FileRef. Such FileRefs are typically obtained via the
 // Pepper file chooser.
 struct PPB_Flash_File_FileRef {
   // The functions below correspond exactly to their module-local counterparts
   // (except in taking FileRefs instead of paths, of course). We omit the
   // functionality which we do not provide for FileRefs.
   int32_t (*OpenFile)(PP_Resource file_ref_id,
                       int32_t mode,
                       PP_FileHandle* file);
   int32_t (*QueryFile)(PP_Resource file_ref_id,
                        struct PP_FileInfo* info);
 };
 
 #endif  // PPAPI_C_PRIVATE_PPB_FLASH_FILE_H_