Revert 113656 - Implement a proxy for Pepper FileIO.

This splits apart the old in-process implementation into a new object in shared_impl that does most of the general tracking. This alllows that code to be shared by the proxy.

BUG=http://crbug.com/101154

Review URL: http://codereview.chromium.org/8764003

TBR=brettw@chromium.org
Review URL: http://codereview.chromium.org/8890037

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

22 files changed, 64 insertions, 1216 deletions

diff --git a/ppapi/api/ppb_file_io.idl b/ppapi/api/ppb_file_io.idl
index d595bdc..0d2c845 100644
--- a/ppapi/api/ppb_file_io.idl
+++ b/ppapi/api/ppb_file_io.idl
@@ -99,9 +99,8 @@ interface PPB_FileIO {
                [in] PP_CompletionCallback callback);
 
   /**
-   * Query() queries info about the file opened by this FileIO object. The
-   * FileIO object must be opened, and there must be no other operations
-   * pending.
+   * Query() queries info about the file opened by this FileIO object. This
+   * function will fail if the FileIO object has not been opened.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a
    * FileIO.
@@ -111,8 +110,6 @@ interface PPB_FileIO {
    * completion of Query().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t Query([in] PP_Resource file_io,
                 [out] PP_FileInfo info,
@@ -120,9 +117,7 @@ interface PPB_FileIO {
 
   /**
    * Touch() Updates time stamps for the file opened by this FileIO object.
-   * This function will fail if the FileIO object has not been opened. The
-   * FileIO object must be opened, and there must be no other operations
-   * pending.
+   * This function will fail if the FileIO object has not been opened.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -132,8 +127,6 @@ interface PPB_FileIO {
    * completion of Touch().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t Touch([in] PP_Resource file_io,
                 [in] PP_Time last_access_time,
@@ -157,8 +150,7 @@ interface PPB_FileIO {
    * @return An The number of bytes read an error code from
    * <code>pp_errors.h</code>. If the return value is 0, then 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, but pending reads
-   * cannot be interleaved with other operations.
+   * callback to queue up parallel reads from the file at different offsets.
    */
   int32_t Read([in] PP_Resource file_io,
                [in] int64_t offset,
@@ -182,8 +174,7 @@ interface PPB_FileIO {
    * @return An The number of bytes written or an error code from
    * <code>pp_errors.h</code>. If the return value is 0, then end-of-file was
    * reached. It is valid to call Write() multiple times with a completion
-   * callback to queue up parallel writes to the file, but pending writes
-   * cannot be interleaved with other operations.
+   * callback to queue up parallel writes to the file at different offsets.
    */
   int32_t Write([in] PP_Resource file_io,
                 [in] int64_t offset,
@@ -192,9 +183,8 @@ interface PPB_FileIO {
                 [in] PP_CompletionCallback callback);
   /**
    * SetLength() 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 and there must be no other operations
-   * pending.
+   * then the extended area of the file is zero-filled.  The FileIO object must
+   * have been opened with write access.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -203,17 +193,13 @@ interface PPB_FileIO {
    * completion of SetLength().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t SetLength([in] PP_Resource file_io,
                     [in] int64_t length,
                     [in] PP_CompletionCallback callback);
 
   /**
-   * Flush() flushes changes to disk.  This call can be very expensive! The
-   * FileIO object must have been opened with write access and there must be no
-   * other operations pending.
+   * Flush() flushes changes to disk.  This call can be very expensive!
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -221,8 +207,6 @@ interface PPB_FileIO {
    * completion of Flush().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t Flush([in] PP_Resource file_io,
                 [in] PP_CompletionCallback callback);
diff --git a/ppapi/c/ppb_file_io.h b/ppapi/c/ppb_file_io.h
index aa028b1..333984b 100644
--- a/ppapi/c/ppb_file_io.h
+++ b/ppapi/c/ppb_file_io.h
@@ -3,7 +3,7 @@
  * found in the LICENSE file.
  */
 
-/* From ppb_file_io.idl modified Thu Dec  1 10:47:02 2011. */
+/* From ppb_file_io.idl modified Mon Aug 29 10:11:34 2011. */
 
 #ifndef PPAPI_C_PPB_FILE_IO_H_
 #define PPAPI_C_PPB_FILE_IO_H_
@@ -117,9 +117,8 @@ struct PPB_FileIO {
                   int32_t open_flags,
                   struct PP_CompletionCallback callback);
   /**
-   * Query() queries info about the file opened by this FileIO object. The
-   * FileIO object must be opened, and there must be no other operations
-   * pending.
+   * Query() queries info about the file opened by this FileIO object. This
+   * function will fail if the FileIO object has not been opened.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a
    * FileIO.
@@ -129,17 +128,13 @@ struct PPB_FileIO {
    * completion of Query().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t (*Query)(PP_Resource file_io,
                    struct PP_FileInfo* info,
                    struct PP_CompletionCallback callback);
   /**
    * Touch() Updates time stamps for the file opened by this FileIO object.
-   * This function will fail if the FileIO object has not been opened. The
-   * FileIO object must be opened, and there must be no other operations
-   * pending.
+   * This function will fail if the FileIO object has not been opened.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -149,8 +144,6 @@ struct PPB_FileIO {
    * completion of Touch().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t (*Touch)(PP_Resource file_io,
                    PP_Time last_access_time,
@@ -173,8 +166,7 @@ struct PPB_FileIO {
    * @return An The number of bytes read an error code from
    * <code>pp_errors.h</code>. If the return value is 0, then 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, but pending reads
-   * cannot be interleaved with other operations.
+   * callback to queue up parallel reads from the file at different offsets.
    */
   int32_t (*Read)(PP_Resource file_io,
                   int64_t offset,
@@ -197,8 +189,7 @@ struct PPB_FileIO {
    * @return An The number of bytes written or an error code from
    * <code>pp_errors.h</code>. If the return value is 0, then end-of-file was
    * reached. It is valid to call Write() multiple times with a completion
-   * callback to queue up parallel writes to the file, but pending writes
-   * cannot be interleaved with other operations.
+   * callback to queue up parallel writes to the file at different offsets.
    */
   int32_t (*Write)(PP_Resource file_io,
                    int64_t offset,
@@ -207,9 +198,8 @@ struct PPB_FileIO {
                    struct PP_CompletionCallback callback);
   /**
    * SetLength() 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 and there must be no other operations
-   * pending.
+   * then the extended area of the file is zero-filled.  The FileIO object must
+   * have been opened with write access.
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -218,16 +208,12 @@ struct PPB_FileIO {
    * completion of SetLength().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t (*SetLength)(PP_Resource file_io,
                        int64_t length,
                        struct PP_CompletionCallback callback);
   /**
-   * Flush() flushes changes to disk.  This call can be very expensive! The
-   * FileIO object must have been opened with write access and there must be no
-   * other operations pending.
+   * Flush() flushes changes to disk.  This call can be very expensive!
    *
    * @param[in] file_io A <code>PP_Resource</code> corresponding to a file
    * FileIO.
@@ -235,8 +221,6 @@ struct PPB_FileIO {
    * completion of Flush().
    *
    * @return An int32_t containing an error code from <code>pp_errors.h</code>.
-   * PP_ERROR_FAILED will be returned if the file isn't opened, and
-   * PP_ERROR_INPROGRESS will be returned if there is another operation pending.
    */
   int32_t (*Flush)(PP_Resource file_io, struct PP_CompletionCallback callback);
   /**
diff --git a/ppapi/ppapi_proxy.gypi b/ppapi/ppapi_proxy.gypi
index 20157f2..8765d44 100644
--- a/ppapi/ppapi_proxy.gypi
+++ b/ppapi/ppapi_proxy.gypi
@@ -70,8 +70,6 @@
         'proxy/ppb_cursor_control_proxy.h',
         'proxy/ppb_file_chooser_proxy.cc',
         'proxy/ppb_file_chooser_proxy.h',
-        'proxy/ppb_file_io_proxy.cc',
-        'proxy/ppb_file_io_proxy.h',
         'proxy/ppb_file_ref_proxy.cc',
         'proxy/ppb_file_ref_proxy.h',
         'proxy/ppb_file_system_proxy.cc',
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi
index f7a01d9..51b52df 100644
--- a/ppapi/ppapi_shared.gypi
+++ b/ppapi/ppapi_shared.gypi
@@ -30,8 +30,6 @@
         '../base/base.gyp:base',
       ],
       'sources': [
-        'shared_impl/file_type_conversion.cc',
-        'shared_impl/file_type_conversion.h',
         'shared_impl/function_group_base.cc',
         'shared_impl/function_group_base.h',
         'shared_impl/host_resource.h',
@@ -52,8 +50,6 @@
         'shared_impl/ppb_char_set_shared.cc',
         'shared_impl/ppb_char_set_shared.h',
         'shared_impl/ppb_crypto_shared.cc',
-        'shared_impl/ppb_file_io_shared.cc',
-        'shared_impl/ppb_file_io_shared.h',
         'shared_impl/ppb_file_ref_shared.cc',
         'shared_impl/ppb_file_ref_shared.h',
         'shared_impl/ppb_font_shared.cc',
diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc
index 2d5b90b..da978e1 100644
--- a/ppapi/proxy/interface_list.cc
+++ b/ppapi/proxy/interface_list.cc
@@ -24,7 +24,6 @@
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_core.h"
-#include "ppapi/c/ppb_file_io.h"
 #include "ppapi/c/ppb_file_ref.h"
 #include "ppapi/c/ppb_file_system.h"
 #include "ppapi/c/ppb_fullscreen.h"
@@ -54,7 +53,6 @@
 #include "ppapi/c/private/ppb_tcp_socket_private.h"
 #include "ppapi/c/private/ppb_udp_socket_private.h"
 #include "ppapi/c/trusted/ppb_broker_trusted.h"
-#include "ppapi/c/trusted/ppb_file_io_trusted.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppb_audio_input_proxy.h"
@@ -64,7 +62,6 @@
 #include "ppapi/proxy/ppb_core_proxy.h"
 #include "ppapi/proxy/ppb_cursor_control_proxy.h"
 #include "ppapi/proxy/ppb_file_chooser_proxy.h"
-#include "ppapi/proxy/ppb_file_io_proxy.h"
 #include "ppapi/proxy/ppb_file_ref_proxy.h"
 #include "ppapi/proxy/ppb_file_system_proxy.h"
 #include "ppapi/proxy/ppb_flash_clipboard_proxy.h"
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 32ac229..b894db9 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -238,22 +238,6 @@ IPC_MESSAGE_ROUTED3(
     int32_t /* result_code (will be != PP_OK on failure */,
     std::vector<ppapi::PPB_FileRef_CreateInfo> /* chosen_files */)
 
-// PPB_FileIO.
-IPC_MESSAGE_ROUTED2(PpapiMsg_PPBFileIO_GeneralComplete,
-                    ppapi::HostResource /* file_io */,
-                    int32_t /* result */)
-IPC_MESSAGE_ROUTED2(PpapiMsg_PPBFileIO_OpenFileComplete,
-                    ppapi::HostResource /* file_io */,
-                    int32_t /* result */)
-IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFileIO_QueryComplete,
-                    ppapi::HostResource /* file_io */,
-                    int32_t /* result */,
-                    PP_FileInfo /* info */)
-IPC_MESSAGE_ROUTED3(PpapiMsg_PPBFileIO_ReadComplete,
-                    ppapi::HostResource /* file_io */,
-                    int32_t /* result */,
-                    std::string /* data */)
-
 // PPB_FileRef.
 IPC_MESSAGE_ROUTED3(
     PpapiMsg_PPBFileRef_CallbackComplete,
@@ -571,43 +555,6 @@ IPC_MESSAGE_ROUTED4(PpapiHostMsg_PPBFileChooser_Show,
                     std::string /* suggested_file_name */,
                     bool /* require_user_gesture */)
 
-// PPB_FileIO.
-IPC_SYNC_MESSAGE_ROUTED1_1(PpapiHostMsg_PPBFileIO_Create,
-                           PP_Instance /* instance */,
-                           ppapi::HostResource /* result */)
-IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileIO_Open,
-                    ppapi::HostResource /* host_resource */,
-                    ppapi::HostResource /* file_ref_resource */,
-                    int32_t /* open_flags */)
-IPC_MESSAGE_ROUTED1(PpapiHostMsg_PPBFileIO_Close,
-                    ppapi::HostResource /* host_resource */)
-IPC_MESSAGE_ROUTED1(PpapiHostMsg_PPBFileIO_Query,
-                    ppapi::HostResource /* host_resource */)
-IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileIO_Touch,
-                    ppapi::HostResource /* host_resource */,
-                    PP_Time /* last_access_time */,
-                    PP_Time /* last_modified_time */)
-IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileIO_Read,
-                    ppapi::HostResource /* host_resource */,
-                    int64_t /* offset */,
-                    int32_t /* bytes_to_read */)
-IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileIO_Write,
-                    ppapi::HostResource /* host_resource */,
-                    int64_t /* offset */,
-                    std::string /* data */)
-IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFileIO_SetLength,
-                    ppapi::HostResource /* host_resource */,
-                    int64_t /* length */)
-IPC_MESSAGE_ROUTED1(PpapiHostMsg_PPBFileIO_Flush,
-                    ppapi::HostResource /* host_resource */)
-IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileIO_WillWrite,
-                    ppapi::HostResource /* host_resource */,
-                    int64_t /* offset */,
-                    int32_t /* bytes_to_write */)
-IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFileIO_WillSetLength,
-                    ppapi::HostResource /* host_resource */,
-                    int64_t /* length */)
-
 // PPB_FileRef.
 IPC_SYNC_MESSAGE_ROUTED2_1(PpapiHostMsg_PPBFileRef_Create,
                            ppapi::HostResource /* file_system */,
diff --git a/ppapi/proxy/ppapi_param_traits.cc b/ppapi/proxy/ppapi_param_traits.cc
index ca03910..ac66648 100644
--- a/ppapi/proxy/ppapi_param_traits.cc
+++ b/ppapi/proxy/ppapi_param_traits.cc
@@ -124,8 +124,7 @@ bool ParamTraits<PP_FileInfo>::Read(const Message* m, void** iter,
       type != PP_FILETYPE_OTHER)
     return false;
   r->type = static_cast<PP_FileType>(type);
-  if (system_type != PP_FILESYSTEMTYPE_INVALID &&
-      system_type != PP_FILESYSTEMTYPE_EXTERNAL &&
+  if (system_type != PP_FILESYSTEMTYPE_EXTERNAL &&
       system_type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
       system_type != PP_FILESYSTEMTYPE_LOCALTEMPORARY)
     return false;
diff --git a/ppapi/proxy/ppb_file_io_proxy.cc b/ppapi/proxy/ppb_file_io_proxy.cc
deleted file mode 100644
index 0acd3ac..0000000
--- a/ppapi/proxy/ppb_file_io_proxy.cc
+++ /dev/null
@@ -1,442 +0,0 @@
-// 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/proxy/ppb_file_io_proxy.h"
-
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/proxy/enter_proxy.h"
-#include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_file_ref_proxy.h"
-#include "ppapi/shared_impl/ppapi_globals.h"
-#include "ppapi/shared_impl/ppb_file_io_shared.h"
-#include "ppapi/shared_impl/resource.h"
-#include "ppapi/shared_impl/resource_tracker.h"
-
-using ppapi::thunk::PPB_FileIO_API;
-using ppapi::thunk::PPB_FileRef_API;
-
-namespace ppapi {
-namespace proxy {
-
-namespace {
-
-// The maximum size we'll support reading in one chunk. The renderer process
-// must allocate a buffer sized according to the request of the plugin. To
-// keep things from getting out of control, we cap the read size to this value.
-// This should generally be OK since the API specifies that it may perform a
-// partial read.
-static const int32_t kMaxReadSize = 33554432;  // 32MB
-
-typedef EnterHostFromHostResourceForceCallback<PPB_FileIO_API> EnterHostFileIO;
-typedef EnterPluginFromHostResource<PPB_FileIO_API> EnterPluginFileIO;
-
-class FileIO : public PPB_FileIO_Shared {
- public:
-  explicit FileIO(const HostResource& host_resource);
-  virtual ~FileIO();
-
-  // PPB_FileIO_API implementation (not provided by FileIOImpl).
-  virtual void Close() OVERRIDE;
-  virtual int32_t GetOSFileDescriptor() OVERRIDE;
-  virtual int32_t WillWrite(int64_t offset,
-                            int32_t bytes_to_write,
-                            PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t WillSetLength(int64_t length,
-                                PP_CompletionCallback callback) OVERRIDE;
-
- private:
-  // FileIOImpl overrides.
-  virtual int32_t OpenValidated(PP_Resource file_ref_resource,
-                                PPB_FileRef_API* file_ref_api,
-                                int32_t open_flags,
-                                PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t QueryValidated(PP_FileInfo* info,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t TouchValidated(PP_Time last_access_time,
-                                 PP_Time last_modified_time,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t ReadValidated(int64_t offset,
-                                char* buffer,
-                                int32_t bytes_to_read,
-                                PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t WriteValidated(int64_t offset,
-                                 const char* buffer,
-                                 int32_t bytes_to_write,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t SetLengthValidated(int64_t length,
-                                     PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t FlushValidated(PP_CompletionCallback callback) OVERRIDE;
-
-  PluginDispatcher* GetDispatcher() const {
-    return PluginDispatcher::GetForResource(this);
-  }
-
-  static const ApiID kApiID = API_ID_PPB_FILE_IO;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(FileIO);
-};
-
-FileIO::FileIO(const HostResource& host_resource)
-    : PPB_FileIO_Shared(host_resource) {
-}
-
-FileIO::~FileIO() {
-  Close();
-}
-
-void FileIO::Close() {
-  if (file_open_) {
-    GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Close(kApiID,
-                                                           host_resource()));
-  }
-}
-
-int32_t FileIO::GetOSFileDescriptor() {
-  return -1;
-}
-
-int32_t FileIO::WillWrite(int64_t offset,
-                          int32_t bytes_to_write,
-                          PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillWrite(
-      kApiID, host_resource(), offset, bytes_to_write));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::WillSetLength(int64_t length,
-                              PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillSetLength(
-      kApiID, host_resource(), length));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::OpenValidated(PP_Resource file_ref_resource,
-                              PPB_FileRef_API* file_ref_api,
-                              int32_t open_flags,
-                              PP_CompletionCallback callback) {
-  Resource* file_ref_object =
-      PpapiGlobals::Get()->GetResourceTracker()->GetResource(file_ref_resource);
-
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Open(
-      kApiID, host_resource(), file_ref_object->host_resource(), open_flags));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::QueryValidated(PP_FileInfo* info,
-                               PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Query(
-      kApiID, host_resource()));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, info);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::TouchValidated(PP_Time last_access_time,
-                               PP_Time last_modified_time,
-                               PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Touch(
-      kApiID, host_resource(), last_access_time, last_modified_time));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::ReadValidated(int64_t offset,
-                              char* buffer,
-                              int32_t bytes_to_read,
-                              PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Read(
-      kApiID, host_resource(), offset, bytes_to_read));
-  RegisterCallback(OPERATION_READ, callback, buffer, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::WriteValidated(int64_t offset,
-                               const char* buffer,
-                               int32_t bytes_to_write,
-                               PP_CompletionCallback callback) {
-  // TODO(brettw) it would be nice to use a shared memory buffer for large
-  // writes rather than having to copy to a string (which will involve a number
-  // of extra copies to serialize over IPC).
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Write(
-      kApiID, host_resource(), offset, std::string(buffer, bytes_to_write)));
-  RegisterCallback(OPERATION_WRITE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::SetLengthValidated(int64_t length,
-                                   PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_SetLength(
-      kApiID, host_resource(), length));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FileIO::FlushValidated(PP_CompletionCallback callback) {
-  GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Flush(
-      kApiID, host_resource()));
-  RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
-  return PP_OK_COMPLETIONPENDING;
-}
-
-}  // namespace
-
-// -----------------------------------------------------------------------------
-
-PPB_FileIO_Proxy::PPB_FileIO_Proxy(Dispatcher* dispatcher)
-    : InterfaceProxy(dispatcher),
-      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-}
-
-PPB_FileIO_Proxy::~PPB_FileIO_Proxy() {
-}
-
-// static
-PP_Resource PPB_FileIO_Proxy::CreateProxyResource(PP_Instance instance) {
-  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
-  if (!dispatcher)
-    return 0;
-
-  HostResource result;
-  dispatcher->Send(new PpapiHostMsg_PPBFileIO_Create(kApiID, instance,
-                                                     &result));
-  if (result.is_null())
-    return 0;
-  return (new FileIO(result))->GetReference();
-}
-
-bool PPB_FileIO_Proxy::OnMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_FileIO_Proxy, msg)
-    // Plugin -> host message.
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Create, OnHostMsgCreate)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Open, OnHostMsgOpen)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Close, OnHostMsgClose)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Query, OnHostMsgQuery)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Touch, OnHostMsgTouch)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Read, OnHostMsgRead)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Write, OnHostMsgWrite)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_SetLength, OnHostMsgSetLength)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_Flush, OnHostMsgFlush)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillWrite, OnHostMsgWillWrite)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileIO_WillSetLength,
-                        OnHostMsgWillSetLength)
-
-    // Host -> plugin messages.
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_GeneralComplete,
-                        OnPluginMsgGeneralComplete)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_OpenFileComplete,
-                        OnPluginMsgOpenFileComplete)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_QueryComplete,
-                        OnPluginMsgQueryComplete)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileIO_ReadComplete,
-                        OnPluginMsgReadComplete)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PPB_FileIO_Proxy::OnHostMsgCreate(PP_Instance instance,
-                                       HostResource* result) {
-  thunk::EnterResourceCreation enter(instance);
-  if (enter.succeeded()) {
-    result->SetHostResource(instance,
-                            enter.functions()->CreateFileIO(instance));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgOpen(const HostResource& host_resource,
-                                     const HostResource& file_ref_resource,
-                                     int32_t open_flags) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-      &PPB_FileIO_Proxy::OpenFileCallbackCompleteInHost, host_resource);
-  if (enter.succeeded()) {
-    enter.SetResult(enter.object()->Open(
-        file_ref_resource.host_resource(), open_flags, enter.callback()));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgClose(const HostResource& host_resource) {
-  EnterHostFromHostResource<PPB_FileIO_API> enter(host_resource);
-  if (enter.succeeded())
-    enter.object()->Close();
-}
-
-void PPB_FileIO_Proxy::OnHostMsgQuery(const HostResource& host_resource) {
-  // The callback will take charge of deleting the FileInfo. The contents must
-  // be defined so we don't send garbage to the plugin in the failure case.
-  PP_FileInfo* info = new PP_FileInfo;
-  memset(info, 0, sizeof(PP_FileInfo));
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::QueryCallbackCompleteInHost,
-                        host_resource, info);
-  if (enter.succeeded())
-    enter.SetResult(enter.object()->Query(info, enter.callback()));
-}
-
-void PPB_FileIO_Proxy::OnHostMsgTouch(const HostResource& host_resource,
-                                      PP_Time last_access_time,
-                                      PP_Time last_modified_time) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded()) {
-    enter.SetResult(enter.object()->Touch(last_access_time, last_modified_time,
-                                          enter.callback()));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgRead(const HostResource& host_resource,
-                                     int64_t offset,
-                                     int32_t bytes_to_read) {
-  // Validate bytes_to_read before allocating below. This value is coming from
-  // the untrusted plugin.
-  bytes_to_read = std::min(bytes_to_read, kMaxReadSize);
-  if (bytes_to_read < 0) {
-    ReadCallbackCompleteInHost(PP_ERROR_FAILED, host_resource,
-                               new std::string());
-    return;
-  }
-
-  // The callback will take charge of deleting the string.
-  std::string* dest = new std::string;
-  dest->resize(bytes_to_read);
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::ReadCallbackCompleteInHost,
-                        host_resource, dest);
-  if (enter.succeeded()) {
-    enter.SetResult(enter.object()->Read(offset,
-                                         bytes_to_read > 0 ? &(*dest)[0] : NULL,
-                                         bytes_to_read, enter.callback()));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgWrite(const HostResource& host_resource,
-                                      int64_t offset,
-                                      const std::string& data) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded()) {
-    enter.SetResult(enter.object()->Write(offset, data.data(), data.size(),
-                                          enter.callback()));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgSetLength(const HostResource& host_resource,
-                                          int64_t length) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded())
-    enter.SetResult(enter.object()->SetLength(length, enter.callback()));
-}
-
-void PPB_FileIO_Proxy::OnHostMsgFlush(const HostResource& host_resource) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded())
-    enter.SetResult(enter.object()->Flush(enter.callback()));
-}
-
-void PPB_FileIO_Proxy::OnHostMsgWillWrite(const HostResource& host_resource,
-                                          int64_t offset,
-                                          int32_t bytes_to_write) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded()) {
-    enter.SetResult(enter.object()->WillWrite(offset, bytes_to_write,
-                                              enter.callback()));
-  }
-}
-
-void PPB_FileIO_Proxy::OnHostMsgWillSetLength(const HostResource& host_resource,
-                                              int64_t length) {
-  EnterHostFileIO enter(host_resource, callback_factory_,
-                        &PPB_FileIO_Proxy::GeneralCallbackCompleteInHost,
-                        host_resource);
-  if (enter.succeeded())
-    enter.SetResult(enter.object()->WillSetLength(length, enter.callback()));
-}
-
-void PPB_FileIO_Proxy::OnPluginMsgGeneralComplete(
-    const HostResource& host_resource,
-    int32_t result) {
-  EnterPluginFileIO enter(host_resource);
-  if (enter.succeeded())
-    static_cast<FileIO*>(enter.object())->ExecuteGeneralCallback(result);
-}
-
-void PPB_FileIO_Proxy::OnPluginMsgOpenFileComplete(
-    const HostResource& host_resource,
-    int32_t result) {
-  EnterPluginFileIO enter(host_resource);
-  if (enter.succeeded())
-    static_cast<FileIO*>(enter.object())->ExecuteOpenFileCallback(result);
-}
-
-void PPB_FileIO_Proxy::OnPluginMsgQueryComplete(
-    const HostResource& host_resource,
-    int32_t result,
-    const PP_FileInfo& info) {
-  EnterPluginFileIO enter(host_resource);
-  if (enter.succeeded())
-    static_cast<FileIO*>(enter.object())->ExecuteQueryCallback(result, info);
-}
-
-void PPB_FileIO_Proxy::OnPluginMsgReadComplete(
-    const HostResource& host_resource,
-    int32_t result,
-    const std::string& data) {
-  EnterPluginFileIO enter(host_resource);
-  if (enter.succeeded()) {
-    // The result code should contain the data size if it's positive.
-    DCHECK((result < 0 && data.size() == 0) ||
-           result == static_cast<int32_t>(data.size()));
-    static_cast<FileIO*>(enter.object())->ExecuteReadCallback(result,
-                                                              data.data());
-  }
-}
-
-void PPB_FileIO_Proxy::GeneralCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource) {
-  Send(new PpapiMsg_PPBFileIO_GeneralComplete(kApiID, host_resource, pp_error));
-}
-
-void PPB_FileIO_Proxy::OpenFileCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource) {
-  Send(new PpapiMsg_PPBFileIO_OpenFileComplete(kApiID, host_resource,
-                                               pp_error));
-}
-
-void PPB_FileIO_Proxy::QueryCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource,
-    PP_FileInfo* info) {
-  Send(new PpapiMsg_PPBFileIO_QueryComplete(kApiID, host_resource, pp_error,
-                                            *info));
-  delete info;
-}
-
-void PPB_FileIO_Proxy::ReadCallbackCompleteInHost(
-    int32_t pp_error,
-    const HostResource& host_resource,
-    std::string* data) {
-  // Only send the amount of data in the string that was actually read.
-  if (pp_error >= 0) {
-    DCHECK(pp_error <= static_cast<int32_t>(data->size()));
-    data->resize(pp_error);
-  }
-  Send(new PpapiMsg_PPBFileIO_ReadComplete(kApiID, host_resource, pp_error,
-                                           *data));
-  delete data;
-}
-
-}  // namespace proxy
-}  // namespace ppapi
diff --git a/ppapi/proxy/ppb_file_io_proxy.h b/ppapi/proxy/ppb_file_io_proxy.h
deleted file mode 100644
index fbc8a16..0000000
--- a/ppapi/proxy/ppb_file_io_proxy.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// 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_PROXY_PPB_FILE_IO_PROXY_H_
-#define PPAPI_PROXY_PPB_FILE_IO_PROXY_H_
-
-#include <string>
-
-#include "base/basictypes.h"
-#include "ppapi/c/pp_file_info.h"
-#include "ppapi/proxy/interface_proxy.h"
-#include "ppapi/proxy/proxy_non_thread_safe_ref_count.h"
-
-namespace ppapi {
-
-class HostResource;
-namespace proxy {
-
-class PPB_FileIO_Proxy : public InterfaceProxy {
- public:
-  explicit PPB_FileIO_Proxy(Dispatcher* dispatcher);
-  virtual ~PPB_FileIO_Proxy();
-
-  static PP_Resource CreateProxyResource(PP_Instance instance);
-
-  // InterfaceProxy implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg);
-
-  static const ApiID kApiID = API_ID_PPB_FILE_IO;
-
- private:
-  // Plugin -> Host message handlers.
-  void OnHostMsgCreate(PP_Instance instance, HostResource* result);
-  void OnHostMsgOpen(const HostResource& host_resource,
-                     const HostResource& file_ref_resource,
-                     int32_t open_flags);
-  void OnHostMsgClose(const HostResource& host_resource);
-  void OnHostMsgQuery(const HostResource& host_resource);
-  void OnHostMsgTouch(const HostResource& host_resource,
-                      PP_Time last_access_time,
-                      PP_Time last_modified_time);
-  void OnHostMsgRead(const HostResource& host_resource,
-                     int64_t offset,
-                     int32_t bytes_to_read);
-  void OnHostMsgWrite(const HostResource& host_resource,
-                      int64_t offset,
-                      const std::string& data);
-  void OnHostMsgSetLength(const HostResource& host_resource,
-                          int64_t length);
-  void OnHostMsgFlush(const HostResource& host_resource);
-  void OnHostMsgWillWrite(const HostResource& host_resource,
-                          int64_t offset,
-                          int32_t bytes_to_write);
-  void OnHostMsgWillSetLength(const HostResource& host_resource,
-                              int64_t length);
-
-  // Host -> Plugin message handlers.
-  void OnPluginMsgGeneralComplete(const HostResource& host_resource,
-                                  int32_t result);
-  void OnPluginMsgOpenFileComplete(const HostResource& host_resource,
-                                  int32_t result);
-  void OnPluginMsgQueryComplete(const HostResource& host_resource,
-                                int32_t result,
-                                const PP_FileInfo& info);
-  void OnPluginMsgReadComplete(const HostResource& host_resource,
-                               int32_t result,
-                               const std::string& data);
-  void OnPluginMsgWriteComplete(const HostResource& host_resource,
-                                int32_t result);
-
-  // Host-side callback handlers. These convert the callbacks to an IPC message
-  // to the plugin.
-  void GeneralCallbackCompleteInHost(int32_t pp_error,
-                                     const HostResource& host_resource);
-  void OpenFileCallbackCompleteInHost(int32_t pp_error,
-                                      const HostResource& host_resource);
-  void QueryCallbackCompleteInHost(int32_t pp_error,
-                                   const HostResource& host_resource,
-                                   PP_FileInfo* info);
-  void ReadCallbackCompleteInHost(int32_t pp_error,
-                                  const HostResource& host_resource,
-                                  std::string* data);
-  pp::CompletionCallbackFactory<PPB_FileIO_Proxy,
-                                ProxyNonThreadSafeRefCount> callback_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(PPB_FileIO_Proxy);
-};
-
-}  // namespace proxy
-}  // namespace ppapi
-
-#endif  // PPAPI_PROXY_PPB_FILE_IO_PROXY_H_
diff --git a/ppapi/proxy/ppb_file_ref_proxy.cc b/ppapi/proxy/ppb_file_ref_proxy.cc
index e481f86..20b522c 100644
--- a/ppapi/proxy/ppb_file_ref_proxy.cc
+++ b/ppapi/proxy/ppb_file_ref_proxy.cc
@@ -33,9 +33,6 @@ class FileRef : public PPB_FileRef_Shared {
   explicit FileRef(const PPB_FileRef_CreateInfo& info);
   virtual ~FileRef();
 
-  // Resource overrides.
-  virtual void LastPluginRefWasDeleted() OVERRIDE;
-
   // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared).
   virtual PP_Resource GetParent() OVERRIDE;
   virtual int32_t MakeDirectory(PP_Bool make_ancestors,
@@ -80,11 +77,6 @@ FileRef::FileRef(const PPB_FileRef_CreateInfo& info)
 }
 
 FileRef::~FileRef() {
-  // The callbacks map should have been cleared by LastPluginRefWasDeleted.
-  DCHECK(pending_callbacks_.empty());
-}
-
-void FileRef::LastPluginRefWasDeleted() {
   // Abort all pending callbacks. Do this by posting a task to avoid reentering
   // the plugin's Release() call that probably deleted this object.
   for (PendingCallbackMap::iterator i = pending_callbacks_.begin();
@@ -93,7 +85,6 @@ void FileRef::LastPluginRefWasDeleted() {
         i->second.func, i->second.user_data,
         static_cast<int32_t>(PP_ERROR_ABORTED)));
   }
-  pending_callbacks_.clear();
 }
 
 PP_Resource FileRef::GetParent() {
diff --git a/ppapi/proxy/ppb_file_ref_proxy.h b/ppapi/proxy/ppb_file_ref_proxy.h
index c0fa23c..5f0f947 100644
--- a/ppapi/proxy/ppb_file_ref_proxy.h
+++ b/ppapi/proxy/ppb_file_ref_proxy.h
@@ -31,8 +31,6 @@ class PPB_FileRef_Proxy : public InterfaceProxy {
 
   static PP_Resource CreateProxyResource(PP_Resource file_system,
                                          const char* path);
-  static PP_Resource CreateProxyResource(
-      const PPB_FileRef_CreateInfo& serialized);
 
   // InterfaceProxy implementation.
   virtual bool OnMessageReceived(const IPC::Message& msg);
@@ -62,7 +60,7 @@ class PPB_FileRef_Proxy : public InterfaceProxy {
   static const ApiID kApiID = API_ID_PPB_FILE_REF;
 
  private:
-  // Plugin -> host message handlers.
+  // Message handlers.
   void OnMsgCreate(const HostResource& file_system,
                    const std::string& path,
                    PPB_FileRef_CreateInfo* result);
diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc
index e758035..52cce18 100644
--- a/ppapi/proxy/resource_creation_proxy.cc
+++ b/ppapi/proxy/resource_creation_proxy.cc
@@ -15,7 +15,6 @@
 #include "ppapi/proxy/ppb_buffer_proxy.h"
 #include "ppapi/proxy/ppb_broker_proxy.h"
 #include "ppapi/proxy/ppb_file_chooser_proxy.h"
-#include "ppapi/proxy/ppb_file_io_proxy.h"
 #include "ppapi/proxy/ppb_file_ref_proxy.h"
 #include "ppapi/proxy/ppb_file_system_proxy.h"
 #include "ppapi/proxy/ppb_flash_menu_proxy.h"
@@ -123,7 +122,8 @@ PP_Resource ResourceCreationProxy::CreateFileChooser(
 }
 
 PP_Resource ResourceCreationProxy::CreateFileIO(PP_Instance instance) {
-  return PPB_FileIO_Proxy::CreateProxyResource(instance);
+  NOTIMPLEMENTED();  // Not proxied yet.
+  return 0;
 }
 
 PP_Resource ResourceCreationProxy::CreateFileRef(PP_Resource file_system,
diff --git a/ppapi/shared_impl/api_id.h b/ppapi/shared_impl/api_id.h
index 73654b0..c8c9362 100644
--- a/ppapi/shared_impl/api_id.h
+++ b/ppapi/shared_impl/api_id.h
@@ -21,7 +21,6 @@ enum ApiID {
   API_ID_PPB_CORE,
   API_ID_PPB_CURSORCONTROL,
   API_ID_PPB_FILE_CHOOSER,
-  API_ID_PPB_FILE_IO,
   API_ID_PPB_FILE_REF,
   API_ID_PPB_FILE_SYSTEM,
   API_ID_PPB_FLASH,
diff --git a/ppapi/shared_impl/file_type_conversion.cc b/ppapi/shared_impl/file_type_conversion.cc
deleted file mode 100644
index a9bd435..0000000
--- a/ppapi/shared_impl/file_type_conversion.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-// 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/shared_impl/file_type_conversion.h"
-
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/c/ppb_file_io.h"
-
-namespace ppapi {
-
-int PlatformFileErrorToPepperError(base::PlatformFileError error_code) {
-  switch (error_code) {
-    case base::PLATFORM_FILE_OK:
-      return PP_OK;
-    case base::PLATFORM_FILE_ERROR_EXISTS:
-      return PP_ERROR_FILEEXISTS;
-    case base::PLATFORM_FILE_ERROR_NOT_FOUND:
-      return PP_ERROR_FILENOTFOUND;
-    case base::PLATFORM_FILE_ERROR_ACCESS_DENIED:
-    case base::PLATFORM_FILE_ERROR_SECURITY:
-      return PP_ERROR_NOACCESS;
-    case base::PLATFORM_FILE_ERROR_NO_MEMORY:
-      return PP_ERROR_NOMEMORY;
-    case base::PLATFORM_FILE_ERROR_NO_SPACE:
-      return PP_ERROR_NOSPACE;
-    case base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY:
-      return PP_ERROR_FAILED;
-    default:
-      return PP_ERROR_FAILED;
-  }
-}
-
-bool PepperFileOpenFlagsToPlatformFileFlags(int32_t pp_open_flags,
-                                            int* flags_out) {
-  if (!flags_out)
-    return false;
-
-  bool pp_read = !!(pp_open_flags & PP_FILEOPENFLAG_READ);
-  bool pp_write = !!(pp_open_flags & PP_FILEOPENFLAG_WRITE);
-  bool pp_create = !!(pp_open_flags & PP_FILEOPENFLAG_CREATE);
-  bool pp_truncate = !!(pp_open_flags & PP_FILEOPENFLAG_TRUNCATE);
-  bool pp_exclusive = !!(pp_open_flags & PP_FILEOPENFLAG_EXCLUSIVE);
-
-  int flags = 0;
-  if (pp_read)
-    flags |= base::PLATFORM_FILE_READ;
-  if (pp_write) {
-    flags |= base::PLATFORM_FILE_WRITE;
-    flags |= base::PLATFORM_FILE_WRITE_ATTRIBUTES;
-  }
-
-  if (pp_truncate && !pp_write)
-    return false;
-
-  if (pp_create) {
-    if (pp_exclusive) {
-      flags |= base::PLATFORM_FILE_CREATE;
-    } else if (pp_truncate) {
-      flags |= base::PLATFORM_FILE_CREATE_ALWAYS;
-    } else {
-      flags |= base::PLATFORM_FILE_OPEN_ALWAYS;
-    }
-  } else if (pp_truncate) {
-    flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
-  } else {
-    flags |= base::PLATFORM_FILE_OPEN;
-  }
-
-  *flags_out = flags;
-  return true;
-}
-
-}  // namespace ppapi
diff --git a/ppapi/shared_impl/file_type_conversion.h b/ppapi/shared_impl/file_type_conversion.h
deleted file mode 100644
index 3ecd404..0000000
--- a/ppapi/shared_impl/file_type_conversion.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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_SHARED_IMPL_FILE_TYPE_CONVERSION_H_
-#define PPAPI_SHARED_IMPL_FILE_TYPE_CONVERSION_H_
-
-#include "base/platform_file.h"
-#include "ppapi/c/pp_stdint.h"
-
-namespace ppapi {
-
-int PlatformFileErrorToPepperError(base::PlatformFileError error_code);
-
-// Converts a PP_FileOpenFlags_Dev flag combination into a corresponding
-// PlatformFileFlags flag combination.
-// Returns |true| if okay.
-bool PepperFileOpenFlagsToPlatformFileFlags(int32_t pp_open_flags,
-                                            int* flags_out);
-
-}  // namespace ppapi
-
-#endif  // PPAPI_SHARED_IMPL_FILE_TYPE_CONVERSION_H_
diff --git a/ppapi/shared_impl/ppb_file_io_shared.cc b/ppapi/shared_impl/ppb_file_io_shared.cc
deleted file mode 100644
index a51c33f..0000000
--- a/ppapi/shared_impl/ppb_file_io_shared.cc
+++ /dev/null
@@ -1,237 +0,0 @@
-// 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/shared_impl/ppb_file_io_shared.h"
-
-#include <string.h>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/message_loop.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/shared_impl/file_type_conversion.h"
-#include "ppapi/shared_impl/time_conversion.h"
-#include "ppapi/thunk/enter.h"
-#include "ppapi/thunk/ppb_file_ref_api.h"
-
-namespace ppapi {
-
-using thunk::EnterResourceNoLock;
-using thunk::PPB_FileIO_API;
-using thunk::PPB_FileRef_API;
-
-PPB_FileIO_Shared::CallbackEntry::CallbackEntry()
-    : read_buffer(NULL),
-      info(NULL) {
-}
-
-PPB_FileIO_Shared::CallbackEntry::CallbackEntry(const CallbackEntry& entry)
-    : callback(entry.callback),
-      read_buffer(entry.read_buffer),
-      info(entry.info) {
-}
-
-PPB_FileIO_Shared::CallbackEntry::~CallbackEntry() {
-}
-
-PPB_FileIO_Shared::PPB_FileIO_Shared(PP_Instance instance)
-    : Resource(instance),
-      file_system_type_(PP_FILESYSTEMTYPE_INVALID),
-      file_open_(false),
-      pending_op_(OPERATION_NONE) {
-}
-
-PPB_FileIO_Shared::PPB_FileIO_Shared(const HostResource& host_resource)
-    : Resource(host_resource),
-      file_system_type_(PP_FILESYSTEMTYPE_INVALID),
-      file_open_(false),
-      pending_op_(OPERATION_NONE) {
-}
-
-PPB_FileIO_Shared::~PPB_FileIO_Shared() {
-  // The callbacks list should have been cleared by LastPluginRefWasDeleted.
-  DCHECK(callbacks_.empty());
-}
-
-void PPB_FileIO_Shared::LastPluginRefWasDeleted() {
-  // Abort all pending callbacks. Do this by posting a task to avoid reentering
-  // the plugin's Release() call that probably deleted this object.
-  for (size_t i = 0; i < callbacks_.size(); i++) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        callbacks_[i].callback.func, callbacks_[i].callback.user_data,
-        static_cast<int32_t>(PP_ERROR_ABORTED)));
-  }
-  callbacks_.erase(callbacks_.begin(), callbacks_.end());
-}
-
-thunk::PPB_FileIO_API* PPB_FileIO_Shared::AsPPB_FileIO_API() {
-  return this;
-}
-
-int32_t PPB_FileIO_Shared::Open(PP_Resource file_ref,
-                                int32_t open_flags,
-                                PP_CompletionCallback callback) {
-  EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-
-  int32_t rv = CommonCallValidation(false, OPERATION_EXCLUSIVE, callback);
-  if (rv != PP_OK)
-    return rv;
-
-  PP_FileSystemType type = enter.object()->GetFileSystemType();
-  if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT &&
-      type != PP_FILESYSTEMTYPE_LOCALTEMPORARY &&
-      type != PP_FILESYSTEMTYPE_EXTERNAL)
-    return PP_ERROR_FAILED;
-  file_system_type_ = type;
-
-  return OpenValidated(file_ref, enter.object(), open_flags, callback);
-}
-
-int32_t PPB_FileIO_Shared::Query(PP_FileInfo* info,
-                                 PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
-  if (rv != PP_OK)
-    return rv;
-  if (!info)
-    return PP_ERROR_BADARGUMENT;
-  return QueryValidated(info, callback);
-}
-
-int32_t PPB_FileIO_Shared::Touch(PP_Time last_access_time,
-                                 PP_Time last_modified_time,
-                                 PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
-  if (rv != PP_OK)
-    return rv;
-  return TouchValidated(last_access_time, last_modified_time, callback);
-}
-
-int32_t PPB_FileIO_Shared::Read(int64_t offset,
-                                char* buffer,
-                                int32_t bytes_to_read,
-                                PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_READ, callback);
-  if (rv != PP_OK)
-    return rv;
-  return ReadValidated(offset, buffer, bytes_to_read, callback);
-}
-
-int32_t PPB_FileIO_Shared::Write(int64_t offset,
-                                 const char* buffer,
-                                 int32_t bytes_to_write,
-                                 PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_WRITE, callback);
-  if (rv != PP_OK)
-    return rv;
-  return WriteValidated(offset, buffer, bytes_to_write, callback);
-}
-
-int32_t PPB_FileIO_Shared::SetLength(int64_t length,
-                                     PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
-  if (rv != PP_OK)
-    return rv;
-  return SetLengthValidated(length, callback);
-}
-
-int32_t PPB_FileIO_Shared::Flush(PP_CompletionCallback callback) {
-  int32_t rv = CommonCallValidation(true, OPERATION_EXCLUSIVE, callback);
-  if (rv != PP_OK)
-    return rv;
-  return FlushValidated(callback);
-}
-
-void PPB_FileIO_Shared::ExecuteGeneralCallback(int32_t pp_error) {
-  RunAndRemoveFirstPendingCallback(pp_error);
-}
-
-void PPB_FileIO_Shared::ExecuteOpenFileCallback(int32_t pp_error) {
-  if (pp_error == PP_OK)
-    file_open_ = true;
-  ExecuteGeneralCallback(pp_error);
-}
-
-void PPB_FileIO_Shared::ExecuteQueryCallback(int32_t pp_error,
-                                             const PP_FileInfo& info) {
-  if (pending_op_ != OPERATION_EXCLUSIVE || callbacks_.empty() ||
-      !callbacks_.front().info) {
-    NOTREACHED();
-    return;
-  }
-  *callbacks_.front().info = info;
-  RunAndRemoveFirstPendingCallback(pp_error);
-}
-
-void PPB_FileIO_Shared::ExecuteReadCallback(int32_t pp_error,
-                                            const char* data) {
-  if (pending_op_ != OPERATION_READ || callbacks_.empty()) {
-    NOTREACHED();
-    return;
-  }
-
-  char* read_buffer = callbacks_.front().read_buffer;
-  DCHECK(data);
-  DCHECK(read_buffer);
-
-  // The result code contains the number of bytes if it's positive.
-  if (pp_error > 0)
-    memcpy(read_buffer, data, pp_error);
-  RunAndRemoveFirstPendingCallback(pp_error);
-}
-
-int32_t PPB_FileIO_Shared::CommonCallValidation(
-    bool should_be_open,
-    OperationType new_op,
-    PP_CompletionCallback callback) {
-  // Only asynchronous operation is supported.
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
-  if (should_be_open) {
-    if (!file_open_)
-      return PP_ERROR_FAILED;
-  } else {
-    if (file_open_)
-      return PP_ERROR_FAILED;
-  }
-
-  if (pending_op_ != OPERATION_NONE &&
-      (pending_op_ != new_op || pending_op_ == OPERATION_EXCLUSIVE)) {
-    return PP_ERROR_INPROGRESS;
-  }
-
-  return PP_OK;
-}
-
-void PPB_FileIO_Shared::RegisterCallback(OperationType op,
-                                         PP_CompletionCallback callback,
-                                         char* read_buffer,
-                                         PP_FileInfo* info) {
-  DCHECK(callback.func);
-  DCHECK(pending_op_ == OPERATION_NONE ||
-         (pending_op_ != OPERATION_EXCLUSIVE && pending_op_ == op));
-
-  CallbackEntry entry;
-  entry.callback = callback;
-  entry.read_buffer = read_buffer;
-  entry.info = info;
-  callbacks_.push_back(entry);
-
-  pending_op_ = op;
-}
-
-void PPB_FileIO_Shared::RunAndRemoveFirstPendingCallback(int32_t result) {
-  DCHECK(!callbacks_.empty());
-
-  CallbackEntry front = callbacks_.front();
-  callbacks_.pop_front();
-  if (callbacks_.empty())
-    pending_op_ = OPERATION_NONE;
-
-  PP_RunCompletionCallback(&front.callback, result);
-}
-
-}  // namespace ppapi
diff --git a/ppapi/shared_impl/ppb_file_io_shared.h b/ppapi/shared_impl/ppb_file_io_shared.h
deleted file mode 100644
index 341db46..0000000
--- a/ppapi/shared_impl/ppb_file_io_shared.h
+++ /dev/null
@@ -1,157 +0,0 @@
-// 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_SHARED_IMPL_PPB_FILE_IO_SHARED_H_
-#define PPAPI_SHARED_IMPL_PPB_FILE_IO_SHARED_H_
-
-#include <deque>
-
-#include "base/compiler_specific.h"
-#include "ppapi/shared_impl/ppapi_shared_export.h"
-#include "ppapi/shared_impl/resource.h"
-#include "ppapi/thunk/ppb_file_io_api.h"
-
-namespace ppapi {
-
-namespace thunk {
-class PPB_FileRef_API;
-}
-
-class PPAPI_SHARED_EXPORT PPB_FileIO_Shared : public Resource,
-                                              public thunk::PPB_FileIO_API {
- public:
-  PPB_FileIO_Shared(PP_Instance instance);
-  PPB_FileIO_Shared(const HostResource& host_resource);
-  ~PPB_FileIO_Shared();
-
-  // Resource overrides.
-  virtual void LastPluginRefWasDeleted() OVERRIDE;
-  virtual thunk::PPB_FileIO_API* AsPPB_FileIO_API() OVERRIDE;
-
-  // PPB_FileIO_API implementation.
-  virtual int32_t Open(PP_Resource file_ref,
-                       int32_t open_flags,
-                       PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Query(PP_FileInfo* info,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Touch(PP_Time last_access_time,
-                        PP_Time last_modified_time,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Read(int64_t offset,
-                       char* buffer,
-                       int32_t bytes_to_read,
-                       PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Write(int64_t offset,
-                        const char* buffer,
-                        int32_t bytes_to_write,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t SetLength(int64_t length,
-                            PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Flush(PP_CompletionCallback callback) OVERRIDE;
-
-  // Callback handler for different types of operations.
-  void ExecuteGeneralCallback(int32_t pp_error);
-  void ExecuteOpenFileCallback(int32_t pp_error);
-  void ExecuteQueryCallback(int32_t pp_error, const PP_FileInfo& info);
-  void ExecuteReadCallback(int32_t pp_error, const char* data);
-
- protected:
-  struct CallbackEntry {
-    CallbackEntry();
-    CallbackEntry(const CallbackEntry& entry);
-    ~CallbackEntry();
-
-    PP_CompletionCallback callback;
-
-    // Pointer back to the caller's read buffer; only used by |Read()|, NULL
-    // for non-read operations. Not owned.
-    char* read_buffer;
-
-    // Pointer back to the caller's PP_FileInfo structure for Query operations.
-    // NULL for non-query operations. Not owned.
-    PP_FileInfo* info;
-  };
-
-  enum OperationType {
-    // There is no pending operation right now.
-    OPERATION_NONE,
-
-    // If there are pending reads, any other kind of async operation is not
-    // allowed.
-    OPERATION_READ,
-
-    // If there are pending writes, any other kind of async operation is not
-    // allowed.
-    OPERATION_WRITE,
-
-    // If there is a pending operation that is neither read nor write, no
-    // further async operation is allowed.
-    OPERATION_EXCLUSIVE
-  };
-
-  // Validated versions of the FileIO API. Subclasses in the proxy and impl
-  // implement these so the common error checking stays here.
-  virtual int32_t OpenValidated(PP_Resource file_ref_resource,
-                                thunk::PPB_FileRef_API* file_ref_api,
-                                int32_t open_flags,
-                                PP_CompletionCallback callback) = 0;
-  virtual int32_t QueryValidated(PP_FileInfo* info,
-                                 PP_CompletionCallback callback) = 0;
-  virtual int32_t TouchValidated(PP_Time last_access_time,
-                                 PP_Time last_modified_time,
-                                 PP_CompletionCallback callback) = 0;
-  virtual int32_t ReadValidated(int64_t offset,
-                                char* buffer,
-                                int32_t bytes_to_read,
-                                PP_CompletionCallback callback) = 0;
-  virtual int32_t WriteValidated(int64_t offset,
-                                 const char* buffer,
-                                 int32_t bytes_to_write,
-                                 PP_CompletionCallback callback) = 0;
-  virtual int32_t SetLengthValidated(int64_t length,
-                                     PP_CompletionCallback callback) = 0;
-  virtual int32_t FlushValidated(PP_CompletionCallback callback) = 0;
-
-  // Called for every "Validated" function.
-  //
-  // This verifies that the callback is valid and that no callback is already
-  // pending, or it is a read(write) request and currently the pending
-  // operations are reads(writes).
-  //
-  // Returns |PP_OK| to indicate that everything is valid or |PP_ERROR_...| if
-  // the call should be aborted and that code returned to the plugin.
-  int32_t CommonCallValidation(bool should_be_open,
-                               OperationType new_op,
-                               PP_CompletionCallback callback);
-
-  // Sets up a pending callback. This should only be called once it is certain
-  // that |PP_OK_COMPLETIONPENDING| will be returned.
-  //
-  // |read_buffer| is only used by read operations, |info| is used only by
-  // query operations.
-  void RegisterCallback(OperationType op,
-                        PP_CompletionCallback callback,
-                        char* read_buffer,
-                        PP_FileInfo* info);
-
-  // Pops the oldest callback from the queue and runs it.
-  void RunAndRemoveFirstPendingCallback(int32_t result);
-
-  // The file system type specified in the Open() call. This will be
-  // PP_FILESYSTEMTYPE_INVALID before open was called. This value does not
-  // indicate that the open command actually succeeded.
-  PP_FileSystemType file_system_type_;
-
-  // Set to true when the file has been successfully opened.
-  bool file_open_;
-
-  std::deque<CallbackEntry> callbacks_;
-  OperationType pending_op_;
-
-  DISALLOW_COPY_AND_ASSIGN(PPB_FileIO_Shared);
-};
-
-}  // namespace ppapi
-
-#endif  // PPAPI_SHARED_IMPL_PPB_FILE_IO_SHARED_H_
diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc
index 057fdef..b04c7e9 100644
--- a/ppapi/tests/test_file_io.cc
+++ b/ppapi/tests/test_file_io.cc
@@ -903,31 +903,6 @@ std::string TestFileIO::TestNotAllowMixedReadWrite() {
   if (rv_2 != PP_ERROR_INPROGRESS)
     return ReportError("FileIO::Read", rv_2);
 
-  // Cannot query while the write is pending.
-  TestCompletionCallback callback_3(instance_->pp_instance(), force_async_);
-  PP_FileInfo info;
-  int32_t rv_3 = file_io.Query(&info, callback_3);
-  if (rv_3 == PP_OK_COMPLETIONPENDING)
-    rv_3 = callback_3.WaitForResult();
-  if (rv_3 != PP_ERROR_INPROGRESS)
-    return ReportError("FileIO::Query", rv_3);
-
-  // Cannot touch while the write is pending.
-  TestCompletionCallback callback_4(instance_->pp_instance(), force_async_);
-  int32_t rv_4 = file_io.Touch(1234.0, 5678.0, callback_4);
-  if (rv_4 == PP_OK_COMPLETIONPENDING)
-    rv_4 = callback_4.WaitForResult();
-  if (rv_4 != PP_ERROR_INPROGRESS)
-    return ReportError("FileIO::Touch", rv_4);
-
-  // Cannot set length while the write is pending.
-  TestCompletionCallback callback_5(instance_->pp_instance(), force_async_);
-  int32_t rv_5 = file_io.SetLength(123, callback_5);
-  if (rv_5 == PP_OK_COMPLETIONPENDING)
-    rv_5 = callback_5.WaitForResult();
-  if (rv_5 != PP_ERROR_INPROGRESS)
-    return ReportError("FileIO::SetLength", rv_5);
-
   callback_1.WaitForResult();
 
   PASS();
@@ -965,14 +940,10 @@ std::string TestFileIO::TestWillWriteWillSetLength() {
   if (!trusted)
     return ReportError("FileIOTrusted", PP_ERROR_FAILED);
 
-  // Get file descriptor. This is only supported in-process for now, so don't
-  // test out of process.
-  const PPB_Testing_Dev* testing_interface = GetTestingInterface();
-  if (testing_interface && !testing_interface->IsOutOfProcess()) {
-    int32_t fd = trusted->GetOSFileDescriptor(file_io.pp_resource());
-    if (fd < 0)
-      return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
-  }
+  // Get file descriptor.
+  int32_t fd = trusted->GetOSFileDescriptor(file_io.pp_resource());
+  if (fd < 0)
+    return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
 
   // Calling WillWrite.
   rv = trusted->WillWrite(
diff --git a/ppapi/tests/test_url_loader.cc b/ppapi/tests/test_url_loader.cc
index fc72948..ce6f6d9 100644
--- a/ppapi/tests/test_url_loader.cc
+++ b/ppapi/tests/test_url_loader.cc
@@ -71,14 +71,22 @@ bool TestURLLoader::Init() {
 
   const PPB_FileIO* file_io_interface = static_cast<const PPB_FileIO*>(
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIO_INTERFACE));
-  if (!file_io_interface)
+  if (testing_interface_->IsOutOfProcess() && file_io_interface) {
+    instance_->AppendError(
+        "FileIO interface is now supported by ppapi proxy: update this test!");
+  } else if (!testing_interface_->IsOutOfProcess() && !file_io_interface) {
     instance_->AppendError("FileIO interface not available");
+  }
 
   file_io_trusted_interface_ = static_cast<const PPB_FileIOTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE));
   url_loader_trusted_interface_ = static_cast<const PPB_URLLoaderTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLLOADERTRUSTED_INTERFACE));
-  if (!testing_interface_->IsOutOfProcess()) {
+  if  (testing_interface_->IsOutOfProcess() && file_io_trusted_interface_) {
+    instance_->AppendError(
+        "FileIOTrusted interface is now supported by ppapi proxy: "
+        "update this test!");
+  } else if (!testing_interface_->IsOutOfProcess()) {
     // Trusted interfaces are not supported under NaCl.
 #if !(defined __native_client__)
     if (!file_io_trusted_interface_)
@@ -462,34 +470,36 @@ std::string TestURLLoader::TestStreamToFile() {
     return ReportError("URLLoader::FinishStreamingToFile", rv);
 
   // FileIO is not yet supported by ppapi/proxy.
-  pp::FileIO reader(instance_);
-  rv = reader.Open(body, PP_FILEOPENFLAG_READ, callback);
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("FileIO::Open force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("FileIO::Open", rv);
+  if (!testing_interface_->IsOutOfProcess()) {
+    pp::FileIO reader(instance_);
+    rv = reader.Open(body, PP_FILEOPENFLAG_READ, callback);
+    if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+      return ReportError("FileIO::Open force_async", rv);
+    if (rv == PP_OK_COMPLETIONPENDING)
+      rv = callback.WaitForResult();
+    if (rv != PP_OK)
+      return ReportError("FileIO::Open", rv);
 
-  std::string data;
-  std::string error = ReadEntireFile(&reader, &data);
-  if (!error.empty())
-    return error;
+    std::string data;
+    std::string error = ReadEntireFile(&reader, &data);
+    if (!error.empty())
+      return error;
 
-  std::string expected_body = "hello\n";
-  if (data.size() != expected_body.size())
-    return "ReadEntireFile returned unexpected content length";
-  if (data != expected_body)
-    return "ReadEntireFile returned unexpected content";
+    std::string expected_body = "hello\n";
+    if (data.size() != expected_body.size())
+      return "ReadEntireFile returned unexpected content length";
+    if (data != expected_body)
+      return "ReadEntireFile returned unexpected content";
 
-  // FileIOTrusted is not supported by NaCl or ppapi/proxy.
-  if (!testing_interface_->IsOutOfProcess()) {
+    // FileIOTrusted is not supported by NaCl or ppapi/proxy.
+    if (!testing_interface_->IsOutOfProcess()) {
 #if !(defined __native_client__)
-    int32_t file_descriptor = file_io_trusted_interface_->GetOSFileDescriptor(
-        reader.pp_resource());
-    if (file_descriptor < 0)
-      return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
+      int32_t file_descriptor = file_io_trusted_interface_->GetOSFileDescriptor(
+          reader.pp_resource());
+      if (file_descriptor < 0)
+        return "FileIO::GetOSFileDescriptor() returned a bad file descriptor.";
 #endif
+    }
   }
   PASS();
 }
diff --git a/ppapi/thunk/interfaces_ppb_private.h b/ppapi/thunk/interfaces_ppb_private.h
index c6770f8..d7c8b69 100644
--- a/ppapi/thunk/interfaces_ppb_private.h
+++ b/ppapi/thunk/interfaces_ppb_private.h
@@ -13,8 +13,6 @@ PROXIED_API(PPB_UDPSocket_Private)
 
 PROXIED_IFACE(PPB_Broker, PPB_BROKER_TRUSTED_INTERFACE_0_2, PPB_BrokerTrusted)
 PROXIED_IFACE(PPB_FileRef, PPB_FILEREFPRIVATE_INTERFACE_0_1, PPB_FileRefPrivate)
-// This uses the FileIO API which is declared in the public stable file.
-PROXIED_IFACE(PPB_FileIO, PPB_FILEIOTRUSTED_INTERFACE_0_4, PPB_FileIOTrusted)
 PROXIED_IFACE(PPB_Instance, PPB_FLASHFULLSCREEN_INTERFACE, PPB_FlashFullscreen)
 PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE,
               PPB_NetAddress_Private)
diff --git a/ppapi/thunk/interfaces_ppb_public_stable.h b/ppapi/thunk/interfaces_ppb_public_stable.h
index f4d5ec3..b81f744 100644
--- a/ppapi/thunk/interfaces_ppb_public_stable.h
+++ b/ppapi/thunk/interfaces_ppb_public_stable.h
@@ -22,7 +22,7 @@ PROXIED_API(PPB_Audio)
 // serialize it to a struct when we need it on the host side.
 UNPROXIED_API(PPB_AudioConfig)
 PROXIED_API(PPB_Core)
-PROXIED_API(PPB_FileIO)
+UNPROXIED_API(PPB_FileIO)
 PROXIED_API(PPB_FileRef)
 PROXIED_API(PPB_FileSystem)
 PROXIED_API(PPB_Graphics2D)
@@ -50,7 +50,7 @@ PROXIED_IFACE(PPB_Audio, PPB_AUDIO_INTERFACE_1_0, PPB_Audio)
 // This has no corresponding _Proxy object since it does no IPC.
 PROXIED_IFACE(NoAPIName, PPB_AUDIO_CONFIG_INTERFACE_1_0, PPB_AudioConfig)
 // Note: Core is special and is registered manually.
-PROXIED_IFACE(PPB_FileIO, PPB_FILEIO_INTERFACE_1_0, PPB_FileIO)
+UNPROXIED_IFACE(PPB_FileIO, PPB_FILEIO_INTERFACE_1_0, PPB_FileIO)
 PROXIED_IFACE(PPB_FileRef, PPB_FILEREF_INTERFACE_1_0, PPB_FileRef)
 PROXIED_IFACE(PPB_FileSystem, PPB_FILESYSTEM_INTERFACE_1_0, PPB_FileSystem)
 PROXIED_IFACE(PPB_Graphics2D, PPB_GRAPHICS_2D_INTERFACE_1_0, PPB_Graphics2D)
diff --git a/ppapi/thunk/thunk.h b/ppapi/thunk/thunk.h
index 00773f3..d59c907 100644
--- a/ppapi/thunk/thunk.h
+++ b/ppapi/thunk/thunk.h
@@ -32,6 +32,7 @@ struct PPB_AudioTrusted;
 struct PPB_BrokerTrusted;
 struct PPB_BufferTrusted;
 struct PPB_FileChooserTrusted;
+struct PPB_FileIOTrusted;
 struct PPB_Flash_Clipboard;
 struct PPB_Flash_Menu;
 struct PPB_Flash_NetConnector;
@@ -58,6 +59,7 @@ PPAPI_THUNK_EXPORT const PPB_BrokerTrusted* GetPPB_Broker_Thunk();
 PPAPI_THUNK_EXPORT const PPB_BufferTrusted* GetPPB_BufferTrusted_Thunk();
 PPAPI_THUNK_EXPORT const PPB_FileChooserTrusted*
     GetPPB_FileChooser_Trusted_Thunk();
+PPAPI_THUNK_EXPORT const PPB_FileIOTrusted* GetPPB_FileIOTrusted_Thunk();
 PPAPI_THUNK_EXPORT const PPB_Flash_Clipboard* GetPPB_Flash_Clipboard_Thunk();
 PPAPI_THUNK_EXPORT const PPB_Flash_Menu* GetPPB_Flash_Menu_Thunk();
 PPAPI_THUNK_EXPORT const PPB_Flash_NetConnector*