This CL is oringialy http://codereview.chromium.org/7210027

I moved to write access repository.
Review URL: http://codereview.chromium.org/7261004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@90629 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 756 insertions, 1 deletions

diff --git a/ppapi/c/pp_file_info.h b/ppapi/c/pp_file_info.h
new file mode 100644
index 0000000..14ccb3c
--- /dev/null
+++ b/ppapi/c/pp_file_info.h
@@ -0,0 +1,37 @@
+/* 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_PP_FILE_INFO_H_
+#define PPAPI_C_PP_FILE_INFO_H_
+
+#include "ppapi/c/pp_macros.h"
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/pp_time.h"
+
+typedef enum {
+  PP_FILETYPE_REGULAR,
+  PP_FILETYPE_DIRECTORY,
+  PP_FILETYPE_OTHER  /* A catch-all for unidentified types. */
+} PP_FileType;
+PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_FileType, 4);
+
+typedef enum {
+  PP_FILESYSTEMTYPE_INVALID = 0,  /* For identifying invalid return values. */
+  PP_FILESYSTEMTYPE_EXTERNAL,
+  PP_FILESYSTEMTYPE_LOCALPERSISTENT,
+  PP_FILESYSTEMTYPE_LOCALTEMPORARY
+} PP_FileSystemType;
+PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_FileSystemType, 4);
+
+struct PP_FileInfo {
+  int64_t size;  /* Measured in bytes */
+  PP_FileType type;
+  PP_FileSystemType system_type;
+  PP_Time creation_time;
+  PP_Time last_access_time;
+  PP_Time last_modified_time;
+};
+PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_FileInfo, 40);
+
+#endif  /* PPAPI_C_PP_FILE_INFO_H_ */
diff --git a/ppapi/c/ppb_file_io.h b/ppapi/c/ppb_file_io.h
new file mode 100644
index 0000000..0f274db
--- /dev/null
+++ b/ppapi/c/ppb_file_io.h
@@ -0,0 +1,119 @@
+/* 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_PPB_FILE_IO_H_
+#define PPAPI_C_PPB_FILE_IO_H_
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_macros.h"
+#include "ppapi/c/pp_resource.h"
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/pp_time.h"
+
+struct PP_CompletionCallback;
+struct PP_FileInfo;
+
+typedef enum {
+  // Requests read access to a file.
+  PP_FILEOPENFLAG_READ      = 1 << 0,
+
+  // Requests write access to a file.  May be combined with
+  // PP_FILEOPENFLAG_READ to request read and write access.
+  PP_FILEOPENFLAG_WRITE     = 1 << 1,
+
+  // Requests that the file be created if it does not exist.  If the file
+  // already exists, then this flag is ignored unless PP_FILEOPENFLAG_EXCLUSIVE
+  // was also specified, in which case FileIO::Open will fail.
+  PP_FILEOPENFLAG_CREATE    = 1 << 2,
+
+  // Requests that the file be truncated to length 0 if it exists and is a
+  // regular file.  PP_FILEOPENFLAG_WRITE must also be specified.
+  PP_FILEOPENFLAG_TRUNCATE  = 1 << 3,
+
+  // Requests that the file is created when this flag is combined with
+  // PP_FILEOPENFLAG_CREATE.  If this flag is specified, and the file already
+  // exists, then the FileIO::Open call will fail.
+  PP_FILEOPENFLAG_EXCLUSIVE = 1 << 4
+} PP_FileOpenFlags;
+PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_FileOpenFlags, 4);
+
+#define PPB_FILEIO_INTERFACE_0_4 "PPB_FileIO;0.4"
+#define PPB_FILEIO_INTERFACE PPB_FILEIO_INTERFACE_0_4
+
+// Use this interface to operate on a regular file (PP_FileType_Regular).
+struct PPB_FileIO {
+  // Creates a new FileIO object.  Returns 0 if the module is invalid.
+  PP_Resource (*Create)(PP_Instance instance);
+
+  // Returns PP_TRUE if the given resource is a FileIO. Returns PP_FALSE if the
+  // resource is invalid or some type other than a FileIO.
+  PP_Bool (*IsFileIO)(PP_Resource resource);
+
+  // Open the specified regular file for I/O according to the given open flags,
+  // which is a bit-mask of the PP_FileOpenFlags values.  Upon success, the
+  // corresponding file is classified as "in use" by this FileIO object until
+  // such time as the FileIO object is closed or destroyed.
+  int32_t (*Open)(PP_Resource file_io,
+                  PP_Resource file_ref,
+                  int32_t open_flags,
+                  struct PP_CompletionCallback callback);
+
+  // Queries info about the file opened by this FileIO object.  Fails if the
+  // FileIO object has not been opened.
+  int32_t (*Query)(PP_Resource file_io,
+                   struct PP_FileInfo* info,
+                   struct PP_CompletionCallback callback);
+
+  // Updates timestamps for the file opened by this FileIO object.  Fails if
+  // the FileIO object has not been opened.
+  int32_t (*Touch)(PP_Resource file_io,
+                   PP_Time last_access_time,
+                   PP_Time last_modified_time,
+                   struct PP_CompletionCallback callback);
+
+  // Read from an offset in the file.  The size of the buffer must be large
+  // enough to hold the specified number of bytes to read.  May perform a
+  // partial read.  Returns the number of bytes read or an error code.  If the
+  // return value is 0, then it indicates that end-of-file was reached.  It is
+  // valid to call Read multiple times with a completion callback to queue up
+  // parallel reads from the file at different offsets.
+  int32_t (*Read)(PP_Resource file_io,
+                  int64_t offset,
+                  char* buffer,
+                  int32_t bytes_to_read,
+                  struct PP_CompletionCallback callback);
+
+  // Write to an offset in the file.  May perform a partial write.  Returns the
+  // number of bytes written or an error code.  It is valid to call Write
+  // multiple times with a completion callback to queue up parallel writes to
+  // the file at different offsets.  The FileIO object must have been opened
+  // with write access.
+  int32_t (*Write)(PP_Resource file_io,
+                   int64_t offset,
+                   const char* buffer,
+                   int32_t bytes_to_write,
+                   struct PP_CompletionCallback callback);
+
+  // Sets the length of the file.  If the file size is extended, then the
+  // extended area of the file is zero-filled.  The FileIO object must have
+  // been opened with write access.
+  int32_t (*SetLength)(PP_Resource file_io,
+                       int64_t length,
+                       struct PP_CompletionCallback callback);
+
+  // Flush changes to disk.  This call can be very expensive!
+  int32_t (*Flush)(PP_Resource file_io,
+                   struct PP_CompletionCallback callback);
+
+  // Cancels any IO that may be pending, and closes the FileIO object.  Any
+  // pending callbacks will still run, reporting PP_Error_Aborted if pending IO
+  // was interrupted.  It is NOT valid to call Open again after a call to this
+  // method.  Note: If the FileIO object is destroyed, and it is still open,
+  // then it will be implicitly closed, so you are not required to call the
+  // Close method.
+  void (*Close)(PP_Resource file_io);
+};
+
+#endif  /* PPAPI_C_PPB_FILE_IO_H_ */
diff --git a/ppapi/c/ppb_file_ref.h b/ppapi/c/ppb_file_ref.h
new file mode 100644
index 0000000..3f6faf7
--- /dev/null
+++ b/ppapi/c/ppb_file_ref.h
@@ -0,0 +1,81 @@
+/* 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_PPB_FILE_REF_H_
+#define PPAPI_C_PPB_FILE_REF_H_
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/c/pp_file_info.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_resource.h"
+#include "ppapi/c/pp_var.h"
+
+struct PP_CompletionCallback;
+
+#define PPB_FILEREF_INTERFACE_0_8 "PPB_FileRef;0.8"
+#define PPB_FILEREF_INTERFACE PPB_FILEREF_INTERFACE_0_8
+
+// A FileRef is a "weak pointer" to a file in a file system.  It contains a
+// PP_FileSystemType identifier and a file path string.
+struct PPB_FileRef {
+  // Creates a weak pointer to a file in the given filesystem. File paths are
+  // POSIX style.  Returns 0 if the path is malformed.
+  PP_Resource (*Create)(PP_Resource file_system, const char* path);
+
+  // Returns PP_TRUE if the given resource is a FileRef. Returns PP_FALSE if the
+  // resource is invalid or some type other than a FileRef.
+  PP_Bool (*IsFileRef)(PP_Resource resource);
+
+  // Returns the file system identifier of this file, or
+  // PP_FILESYSTEMTYPE_INVALID if the file ref is invalid.
+  PP_FileSystemType (*GetFileSystemType)(PP_Resource file_ref);
+
+  // Returns the name of the file. The value returned by this function does not
+  // include any path component (such as the name of the parent directory, for
+  // example). It is just the name of the file. To get the full file path, use
+  // the GetPath() function.
+  struct PP_Var (*GetName)(PP_Resource file_ref);
+
+  // Returns the absolute path of the file.  This method fails if the file
+  // system type is PP_FileSystemType_External.
+  struct PP_Var (*GetPath)(PP_Resource file_ref);
+
+  // Returns the parent directory of this file.  If file_ref points to the root
+  // of the filesystem, then the root is returned.  This method fails if the
+  // file system type is PP_FileSystemType_External.
+  PP_Resource (*GetParent)(PP_Resource file_ref);
+
+  // Makes a new directory in the filesystem as well as any parent directories
+  // if the make_ancestors parameter is PP_TRUE.  It is not valid to make a
+  // directory in the external filesystem.  Fails if the directory already
+  // exists or if ancestor directories do not exist and make_ancestors was not
+  // passed as PP_TRUE.
+  int32_t (*MakeDirectory)(PP_Resource directory_ref,
+                           PP_Bool make_ancestors,
+                           struct PP_CompletionCallback callback);
+
+  // Updates timestamps for a file.  You must have write access to the file if
+  // it exists in the external filesystem.
+  int32_t (*Touch)(PP_Resource file_ref,
+                   PP_Time last_access_time,
+                   PP_Time last_modified_time,
+                   struct PP_CompletionCallback callback);
+
+  // Delete a file or directory.  If file_ref refers to a directory, then the
+  // directory must be empty.  It is an error to delete a file or directory
+  // that is in use.  It is not valid to delete a file in the external
+  // filesystem.
+  int32_t (*Delete)(PP_Resource file_ref,
+                    struct PP_CompletionCallback callback);
+
+  // Rename a file or directory.  file_ref and new_file_ref must both refer to
+  // files in the same filesystem.  It is an error to rename a file or
+  // directory that is in use.  It is not valid to rename a file in the
+  // external filesystem.
+  int32_t (*Rename)(PP_Resource file_ref,
+                    PP_Resource new_file_ref,
+                    struct PP_CompletionCallback callback);
+};
+
+#endif  /* PPAPI_C_PPB_FILE_REF_H_ */
diff --git a/ppapi/c/ppb_file_system.h b/ppapi/c/ppb_file_system.h
new file mode 100644
index 0000000..692aa9c
--- /dev/null
+++ b/ppapi/c/ppb_file_system.h
@@ -0,0 +1,47 @@
+/* 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_PPB_FILE_SYSTEM_H_
+#define PPAPI_C_PPB_FILE_SYSTEM_H_
+
+#include "ppapi/c/pp_bool.h"
+#include "ppapi/c/pp_file_info.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_resource.h"
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/pp_time.h"
+
+struct PP_CompletionCallback;
+
+#define PPB_FILESYSTEM_INTERFACE_0_6 "PPB_FileSystem;0.6"
+#define PPB_FILESYSTEM_INTERFACE PPB_FILESYSTEM_INTERFACE_0_6
+
+struct PPB_FileSystem {
+  /** Creates a filesystem object of the given type. */
+  PP_Resource (*Create)(PP_Instance instance, PP_FileSystemType type);
+
+  /** Returns PP_TRUE if the given resource is a FileSystem. */
+  PP_Bool (*IsFileSystem)(PP_Resource resource);
+
+  /**
+   * Opens the file system. A file system must be opened before running any
+   * other operation on it.
+   *
+   * TODO(brettw) clarify whether this must have completed before a file can
+   * be opened in it. Clarify what it means to be "completed."
+   */
+  int32_t (*Open)(PP_Resource file_system,
+                  int64_t expected_size,
+                  struct PP_CompletionCallback callback);
+
+  /**
+   * Returns the type of the given file system.
+   *
+   * Returns PP_FILESYSTEMTYPE_INVALID if the given resource is not a valid
+   * filesystem. It is valid to call this function even before Open completes.
+   */
+  PP_FileSystemType (*GetType)(PP_Resource file_system);
+};
+
+#endif  /* PPAPI_C_PPB_FILE_SYSTEM_H_ */
diff --git a/ppapi/c/trusted/ppb_file_io_trusted.h b/ppapi/c/trusted/ppb_file_io_trusted.h
new file mode 100644
index 0000000..44e6e43
--- /dev/null
+++ b/ppapi/c/trusted/ppb_file_io_trusted.h
@@ -0,0 +1,47 @@
+/* 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_PPB_FILE_IO_TRUSTED_H_
+#define PPAPI_C_PPB_FILE_IO_TRUSTED_H_
+
+#include "ppapi/c/pp_resource.h"
+#include "ppapi/c/pp_stdint.h"
+
+struct PP_CompletionCallback;
+
+#define PPB_FILEIOTRUSTED_INTERFACE_0_3 "PPB_FileIOTrusted;0.3"
+#define PPB_FILEIOTRUSTED_INTERFACE PPB_FILEIOTRUSTED_INTERFACE_0_3
+
+// Available only to trusted implementations.
+struct PPB_FileIOTrusted {
+  // Returns a file descriptor corresponding to the given FileIO object. On
+  // Windows, returns a HANDLE; on all other platforms, returns a POSIX file
+  // descriptor. The FileIO object must have been opened with a successful
+  // call to FileIO::Open.  The file descriptor will be closed automatically
+  // when the FileIO object is closed or destroyed.
+  int32_t (*GetOSFileDescriptor)(PP_Resource file_io);
+
+  // Notifies the browser that underlying file will be modified.  This gives
+  // the browser the opportunity to apply quota restrictions and possibly
+  // return an error to indicate that the write is not allowed.
+  int32_t (*WillWrite)(PP_Resource file_io,
+                       int64_t offset,
+                       int32_t bytes_to_write,
+                       struct PP_CompletionCallback callback);
+
+  // Notifies the browser that underlying file will be modified.  This gives
+  // the browser the opportunity to apply quota restrictions and possibly
+  // return an error to indicate that the write is not allowed.
+  int32_t (*WillSetLength)(PP_Resource file_io,
+                           int64_t length,
+                           struct PP_CompletionCallback callback);
+
+  // TODO(darin): Maybe unify the above into a single WillChangeFileSize
+  // method?  The above methods have the advantage of mapping to PPB_FileIO
+  // Write and SetLength calls.  WillChangeFileSize would require the caller to
+  // compute the file size resulting from a Write call, which may be
+  // undesirable.
+};
+
+#endif  /* PPAPI_C_PPB_FILE_IO_TRUSTED_H_ */
diff --git a/ppapi/cpp/file_io.cc b/ppapi/cpp/file_io.cc
new file mode 100644
index 0000000..ca6760b
--- /dev/null
+++ b/ppapi/cpp/file_io.cc
@@ -0,0 +1,110 @@
+// 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 "ppapi/cpp/file_io.h"
+
+#include "ppapi/c/ppb_file_io.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/trusted/ppb_file_io_trusted.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/file_ref.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/module_impl.h"
+
+namespace pp {
+
+namespace {
+
+template <> const char* interface_name<PPB_FileIO>() {
+  return PPB_FILEIO_INTERFACE;
+}
+
+}  // namespace
+
+FileIO::FileIO() {
+}
+
+FileIO::FileIO(Instance* instance) {
+  if (!has_interface<PPB_FileIO>())
+    return;
+  PassRefFromConstructor(get_interface<PPB_FileIO>()->Create(
+      instance->pp_instance()));
+}
+
+FileIO::FileIO(const FileIO& other)
+    : Resource(other) {
+}
+
+int32_t FileIO::Open(const FileRef& file_ref,
+                     int32_t open_flags,
+                     const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Open(
+      pp_resource(), file_ref.pp_resource(), open_flags,
+      cc.pp_completion_callback());
+}
+
+int32_t FileIO::Query(PP_FileInfo* result_buf,
+                      const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Query(
+      pp_resource(), result_buf, cc.pp_completion_callback());
+}
+
+int32_t FileIO::Touch(PP_Time last_access_time,
+                      PP_Time last_modified_time,
+                      const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Touch(
+      pp_resource(), last_access_time, last_modified_time,
+      cc.pp_completion_callback());
+}
+
+int32_t FileIO::Read(int64_t offset,
+                     char* buffer,
+                     int32_t bytes_to_read,
+                     const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Read(pp_resource(),
+      offset, buffer, bytes_to_read, cc.pp_completion_callback());
+}
+
+int32_t FileIO::Write(int64_t offset,
+                      const char* buffer,
+                      int32_t bytes_to_write,
+                      const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Write(
+      pp_resource(), offset, buffer, bytes_to_write,
+      cc.pp_completion_callback());
+}
+
+int32_t FileIO::SetLength(int64_t length,
+                          const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->SetLength(
+      pp_resource(), length, cc.pp_completion_callback());
+}
+
+int32_t FileIO::Flush(const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileIO>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileIO>()->Flush(
+      pp_resource(), cc.pp_completion_callback());
+}
+
+void FileIO::Close() {
+  if (!has_interface<PPB_FileIO>())
+    return;
+  get_interface<PPB_FileIO>()->Close(pp_resource());
+}
+
+}  // namespace pp
diff --git a/ppapi/cpp/file_io.h b/ppapi/cpp/file_io.h
new file mode 100644
index 0000000..309984d
--- /dev/null
+++ b/ppapi/cpp/file_io.h
@@ -0,0 +1,52 @@
+// 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_CPP_FILE_IO_H_
+#define PPAPI_CPP_FILE_IO_H_
+
+#include "ppapi/c/pp_time.h"
+#include "ppapi/cpp/resource.h"
+
+struct PP_FileInfo;
+
+namespace pp {
+
+class CompletionCallback;
+class FileRef;
+class Instance;
+
+class FileIO : public Resource {
+ public:
+  // Constructs an is_null resource.
+  FileIO();
+
+  FileIO(Instance* instance);
+  FileIO(const FileIO& other);
+
+    // PPB_FileIO methods:
+  int32_t Open(const FileRef& file_ref,
+               int32_t open_flags,
+               const CompletionCallback& cc);
+  int32_t Query(PP_FileInfo* result_buf,
+                const CompletionCallback& cc);
+  int32_t Touch(PP_Time last_access_time,
+                PP_Time last_modified_time,
+                const CompletionCallback& cc);
+  int32_t Read(int64_t offset,
+               char* buffer,
+               int32_t bytes_to_read,
+               const CompletionCallback& cc);
+  int32_t Write(int64_t offset,
+                const char* buffer,
+                int32_t bytes_to_write,
+                const CompletionCallback& cc);
+  int32_t SetLength(int64_t length,
+                    const CompletionCallback& cc);
+  int32_t Flush(const CompletionCallback& cc);
+  void Close();
+};
+
+}  // namespace pp
+
+#endif  // PPAPI_CPP_FILE_IO_H_
diff --git a/ppapi/cpp/file_ref.cc b/ppapi/cpp/file_ref.cc
new file mode 100644
index 0000000..fdae3d8
--- /dev/null
+++ b/ppapi/cpp/file_ref.cc
@@ -0,0 +1,114 @@
+// 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 "ppapi/cpp/file_ref.h"
+
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/file_system.h"
+#include "ppapi/cpp/module_impl.h"
+
+
+namespace pp {
+
+namespace {
+
+template <> const char* interface_name<PPB_FileRef>() {
+  return PPB_FILEREF_INTERFACE;
+}
+
+}  // namespace
+
+FileRef::FileRef(PP_Resource resource) : Resource(resource) {
+}
+
+FileRef::FileRef(PassRef, PP_Resource resource) {
+  PassRefFromConstructor(resource);
+}
+
+FileRef::FileRef(const FileSystem& file_system,
+                 const char* path) {
+  if (!has_interface<PPB_FileRef>())
+    return;
+  PassRefFromConstructor(get_interface<PPB_FileRef>()->Create(
+      file_system.pp_resource(), path));
+}
+
+FileRef::FileRef(const FileRef& other)
+    : Resource(other) {
+}
+
+PP_FileSystemType FileRef::GetFileSystemType() const {
+  if (!has_interface<PPB_FileRef>())
+    return PP_FILESYSTEMTYPE_EXTERNAL;
+  return get_interface<PPB_FileRef>()->GetFileSystemType(pp_resource());
+}
+
+Var FileRef::GetName() const {
+  if (!has_interface<PPB_FileRef>())
+    return Var();
+  return Var(Var::PassRef(),
+             get_interface<PPB_FileRef>()->GetName(pp_resource()));
+}
+
+Var FileRef::GetPath() const {
+  if (!has_interface<PPB_FileRef>())
+    return Var();
+  return Var(Var::PassRef(),
+             get_interface<PPB_FileRef>()->GetPath(pp_resource()));
+}
+
+FileRef FileRef::GetParent() const {
+  if (!has_interface<PPB_FileRef>())
+    return FileRef();
+  return FileRef(PassRef(),
+                     get_interface<PPB_FileRef>()->GetParent(
+                         pp_resource()));
+}
+
+int32_t FileRef::MakeDirectory(const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileRef>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileRef>()->MakeDirectory(
+      pp_resource(),
+      PP_FALSE,  // make_ancestors
+      cc.pp_completion_callback());
+}
+
+int32_t FileRef::MakeDirectoryIncludingAncestors(
+    const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileRef>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileRef>()->MakeDirectory(
+      pp_resource(),
+      PP_TRUE,  // make_ancestors
+      cc.pp_completion_callback());
+}
+
+int32_t FileRef::Touch(PP_Time last_access_time,
+                       PP_Time last_modified_time,
+                       const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileRef>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileRef>()->Touch(
+      pp_resource(), last_access_time, last_modified_time,
+      cc.pp_completion_callback());
+}
+
+int32_t FileRef::Delete(const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileRef>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileRef>()->Delete(
+      pp_resource(), cc.pp_completion_callback());
+}
+
+int32_t FileRef::Rename(const FileRef& new_file_ref,
+                        const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileRef>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileRef>()->Rename(
+      pp_resource(), new_file_ref.pp_resource(), cc.pp_completion_callback());
+}
+
+}  // namespace pp
diff --git a/ppapi/cpp/file_ref.h b/ppapi/cpp/file_ref.h
new file mode 100644
index 0000000..f0865fc
--- /dev/null
+++ b/ppapi/cpp/file_ref.h
@@ -0,0 +1,66 @@
+// 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_CPP_FILE_REF_H_
+#define PPAPI_CPP_FILE_REF_H_
+
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/ppb_file_ref.h"
+#include "ppapi/cpp/resource.h"
+#include "ppapi/cpp/var.h"
+
+namespace pp {
+
+class CompletionCallback;
+class FileSystem;
+
+class FileRef : public Resource {
+ public:
+  // Creates an is_null() FileRef object.
+  FileRef() {}
+
+  // This constructor is used when we've gotten a PP_Resource as a return value
+  // that we need to addref.
+  explicit FileRef(PP_Resource resource);
+
+  // This constructor is used when we've gotten a PP_Resource as a return value
+  // that has already been addref'ed for us.
+  struct PassRef {};
+  FileRef(PassRef, PP_Resource resource);
+
+  // Creates a FileRef pointing to a path in the given filesystem.
+  FileRef(const FileSystem& file_system, const char* path);
+
+  FileRef(const FileRef& other);
+
+  // Returns the file system type.
+  PP_FileSystemType GetFileSystemType() const;
+
+  // Returns the name of the file.
+  Var GetName() const;
+
+  // Returns the absolute path of the file.  See PPB_FileRef::GetPath for more
+  // details.
+  Var GetPath() const;
+
+  // Returns the parent directory of this file.  See PPB_FileRef::GetParent for
+  // more details.
+  FileRef GetParent() const;
+
+  int32_t MakeDirectory(const CompletionCallback& cc);
+
+  int32_t MakeDirectoryIncludingAncestors(const CompletionCallback& cc);
+
+  int32_t Touch(PP_Time last_access_time,
+                PP_Time last_modified_time,
+                const CompletionCallback& cc);
+
+  int32_t Delete(const CompletionCallback& cc);
+
+  int32_t Rename(const FileRef& new_file_ref, const CompletionCallback& cc);
+};
+
+}  // namespace pp
+
+#endif  // PPAPI_CPP_FILE_REF_H_
diff --git a/ppapi/cpp/file_system.cc b/ppapi/cpp/file_system.cc
new file mode 100644
index 0000000..c5312bb
--- /dev/null
+++ b/ppapi/cpp/file_system.cc
@@ -0,0 +1,40 @@
+// 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 "ppapi/cpp/file_system.h"
+
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/ppb_file_system.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/file_ref.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/module_impl.h"
+
+namespace pp {
+
+namespace {
+
+template <> const char* interface_name<PPB_FileSystem>() {
+  return PPB_FILESYSTEM_INTERFACE;
+}
+
+}  // namespace
+
+FileSystem::FileSystem(Instance* instance,
+                       PP_FileSystemType type) {
+  if (!has_interface<PPB_FileSystem>())
+    return;
+  PassRefFromConstructor(get_interface<PPB_FileSystem>()->Create(
+      instance->pp_instance(), type));
+}
+
+int32_t FileSystem::Open(int64_t expected_size,
+                         const CompletionCallback& cc) {
+  if (!has_interface<PPB_FileSystem>())
+    return PP_ERROR_NOINTERFACE;
+  return get_interface<PPB_FileSystem>()->Open(
+      pp_resource(), expected_size, cc.pp_completion_callback());
+}
+
+}  // namespace pp
diff --git a/ppapi/cpp/file_system.h b/ppapi/cpp/file_system.h
new file mode 100644
index 0000000..f5beb66
--- /dev/null
+++ b/ppapi/cpp/file_system.h
@@ -0,0 +1,32 @@
+// 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_CPP_FILE_SYSTEM_H_
+#define PPAPI_CPP_FILE_SYSTEM_H_
+
+#include "ppapi/c/pp_file_info.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/pp_time.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/resource.h"
+
+struct PP_FileInfo;
+
+namespace pp {
+
+class CompletionCallback;
+class FileRef;
+
+// Wraps methods from ppb_file_system.h
+class FileSystem : public Resource {
+ public:
+  FileSystem(Instance* instance, PP_FileSystemType type);
+
+  int32_t Open(int64_t expected_size, const CompletionCallback& cc);
+};
+
+}  // namespace pp
+
+#endif  // PPAPI_CPP_FILE_SYSTEM_H_
diff --git a/ppapi/ppapi_cpp.gypi b/ppapi/ppapi_cpp.gypi
index e548733..045af8b 100644
--- a/ppapi/ppapi_cpp.gypi
+++ b/ppapi/ppapi_cpp.gypi
@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Chromium Authors. All rights reserved.
+# 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.
 
@@ -16,6 +16,7 @@
         'c/pp_bool.h',
         'c/pp_completion_callback.h',
         'c/pp_errors.h',
+        'c/pp_file_info.h',
         'c/pp_input_event.h',
         'c/pp_instance.h',
         'c/pp_macros.h',
@@ -31,6 +32,9 @@
         'c/ppb_audio.h',
         'c/ppb_audio_config.h',
         'c/ppb_core.h',
+        'c/ppb_file_io.h',
+        'c/ppb_file_ref.h',
+        'c/ppb_file_system.h',
         'c/ppb_graphics_2d.h',
         'c/ppb_image_data.h',
         'c/ppb_instance.h',
@@ -133,6 +137,12 @@
         'cpp/completion_callback.h',
         'cpp/core.cc',
         'cpp/core.h',
+        'cpp/file_io.cc',
+        'cpp/file_io.h',
+        'cpp/file_ref.cc',
+        'cpp/file_ref.h',
+        'cpp/file_system.cc',
+        'cpp/file_system.h',
         'cpp/graphics_2d.cc',
         'cpp/graphics_2d.h',
         'cpp/image_data.cc',