Clean up the file dev interfaces. The combination of some dev and some non

ppapi/tests/test_file_io.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_file_io.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include "base/memory/scoped_ptr.h"
+#include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_errors.h"
-#include "ppapi/c/dev/ppb_file_io_dev.h"
-#include "ppapi/c/dev/ppb_testing_dev.h"
-#include "ppapi/cpp/dev/file_io_dev.h"
-#include "ppapi/cpp/dev/file_ref_dev.h"
+#include "ppapi/c/ppb_file_io.h"
+#include "ppapi/cpp/dev/file_io.h"
+#include "ppapi/cpp/dev/file_ref.h"

[dmichael (off chromium), 2011/07/15 16:31:46]

missed dev in the directory of these two

 #include "ppapi/cpp/dev/file_system_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(FileIO);
 
 namespace {
 
@@ skipping 26 matching lines @@
       result += kFlagNames[index];
     }
   }
   if (first_flag)
     result += "[None]";
 
   return result;
 }
 
 int32_t ReadEntireFile(PP_Instance instance,
-                       pp::FileIO_Dev* file_io,
+                       pp::FileIO* file_io,
                        int32_t offset,
                        std::string* data) {
   TestCompletionCallback callback(instance);
   char buf[256];
   int32_t read_offset = offset;
 
   for (;;) {
     int32_t rv = file_io->Read(read_offset, buf, sizeof(buf), callback);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return rv;
     if (rv == 0)
       break;
     read_offset += rv;
     data->append(buf, rv);
   }
 
   return PP_OK;
 }
 
 int32_t WriteEntireBuffer(PP_Instance instance,
-                          pp::FileIO_Dev* file_io,
+                          pp::FileIO* file_io,
                           int32_t offset,
                           const std::string& data) {
   TestCompletionCallback callback(instance);
   int32_t write_offset = offset;
   const char* buf = data.c_str();
   int32_t size = data.size();
 
   while (write_offset < offset + size) {
     int32_t rv = file_io->Write(write_offset, &buf[write_offset - offset],
                                 size - write_offset + offset, callback);
@@ skipping 25 matching lines @@
   RUN_TEST_FORCEASYNC_AND_NOT(NotAllowMixedReadWrite);
 
   // TODO(viettrungluu): add tests:
   //  - that PP_ERROR_PENDING is correctly returned
   //  - that operations respect the file open modes (flags)
 }
 
 std::string TestFileIO::TestOpen() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_open");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_open");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
   std::string result;
   result = MatchOpenExpectations(
@@ skipping 76 matching lines @@
       INVALID_FLAG_COMBINATION);
   if (!result.empty())
     return result;
 
   PASS();
 }
 
 std::string TestFileIO::TestReadWriteSetLength() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_read_write_setlength");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_read_write_setlength");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io(instance_);
+  pp::FileIO file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
@@ skipping 92 matching lines @@
   if (read_buffer != std::string("testtest\0\0\0\0", 12))
     return ReportMismatch("FileIO::Read", read_buffer,
                           std::string("testtest\0\0\0\0", 12));
 
   PASS();
 }
 
 std::string TestFileIO::TestTouchQuery() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileRef_Dev file_ref(file_system, "/file_touch");
-  pp::FileIO_Dev file_io(instance_);
+  pp::FileRef file_ref(file_system, "/file_touch");
+  pp::FileIO file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_WRITE,
                     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)
@@ skipping 13 matching lines @@
   const PP_Time last_access_time = 123 * 24 * 3600.0;
   const PP_Time last_modified_time = 246.0;
   rv = file_io.Touch(last_access_time, last_modified_time, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Touch force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Touch", rv);
 
-  PP_FileInfo_Dev info;
+  PP_FileInfo info;
   rv = file_io.Query(&info, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Query force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Query", rv);
 
   if ((info.size != 4) ||
       (info.type != PP_FILETYPE_REGULAR) ||
@@ skipping 10 matching lines @@
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Query", rv);
 
   PASS();
 }
 
 std::string TestFileIO::TestAbortCalls() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_abort_calls");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_abort_calls");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
   // First, create a file which to do ops on.
   {
-    pp::FileIO_Dev file_io(instance_);
+    pp::FileIO file_io(instance_);
     rv = file_io.Open(file_ref,
                       PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                       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);
 
     // N.B.: Should write at least 3 bytes.
     rv = WriteEntireBuffer(instance_->pp_instance(),
                            &file_io,
                            0,
                            "foobarbazquux");
     if (rv != PP_OK)
       return ReportError("FileIO::Write", rv);
   }
 
   // Abort |Open()|.
   {
     callback.reset_run_count();
-    rv = pp::FileIO_Dev(instance_)
+    rv = pp::FileIO(instance_)
         .Open(file_ref, PP_FILEOPENFLAG_READ,callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("FileIO::Open force_async", rv);
     if (callback.run_count() > 0)
       return "FileIO::Open ran callback synchronously.";
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Open not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Open", rv);
     }
   }
 
   // Abort |Query()|.
   {
-    PP_FileInfo_Dev info = { 0 };
+    PP_FileInfo info = { 0 };
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, 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);
 
       callback.reset_run_count();
       rv = file_io.Query(&info, callback);
       if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
         return ReportError("FileIO::Query force_async", rv);
     }  // Destroy |file_io|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |info| doesn't get written to.
-      PP_FileInfo_Dev info_copy;
+      PP_FileInfo info_copy;
       memcpy(&info_copy, &info, sizeof(info));
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Query not aborted.";
       if (memcmp(&info_copy, &info, sizeof(info)) != 0)
         return "FileIO::Query wrote data after resource destruction.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Query", rv);
     }
   }
 
   // Abort |Touch()|.
   {
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, 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);
 
       callback.reset_run_count();
       rv = file_io.Touch(0, 0, callback);
       if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
         return ReportError("FileIO::Touch force_async", rv);
     }  // Destroy |file_io|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Touch not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Touch", rv);
     }
   }
 
   // Abort |Read()|.
   {
     char buf[3] = { 0 };
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, 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);
 
       callback.reset_run_count();
       rv = file_io.Read(0, buf, sizeof(buf), callback);
@@ skipping 11 matching lines @@
         return "FileIO::Read wrote data after resource destruction.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Read", rv);
     }
   }
 
   // Abort |Write()|.
   {
     char buf[3] = { 0 };
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, 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);
 
       callback.reset_run_count();
       rv = file_io.Write(0, buf, sizeof(buf), callback);
       if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
         return ReportError("FileIO::Write force_async", rv);
     }  // Destroy |file_io|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Write not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Write", rv);
     }
   }
 
   // Abort |SetLength()|.
   {
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, 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);
 
       callback.reset_run_count();
       rv = file_io.SetLength(3, callback);
       if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
         return ReportError("FileIO::SetLength force_async", rv);
     }  // Destroy |file_io|.
     if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::SetLength not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::SetLength", rv);
     }
   }
 
   // Abort |Flush()|.
   {
     {
-      pp::FileIO_Dev file_io(instance_);
+      pp::FileIO file_io(instance_);
       rv = file_io.Open(file_ref, 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);
 
       callback.reset_run_count();
       rv = file_io.Flush(callback);
@@ skipping 10 matching lines @@
   }
 
   // TODO(viettrungluu): Also test that Close() aborts callbacks.
   // crbug.com/69457
 
   PASS();
 }
 
 std::string TestFileIO::TestParallelReads() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_parallel_reads");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_parallel_reads");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io(instance_);
+  pp::FileIO file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
@@ skipping 77 matching lines @@
               sizeof(expected_result_2)) != 0) {
     return std::string(
         "Parallel FileIO::Read operations have written into wrong buffers.");
   }
 
   PASS();
 }
 
 std::string TestFileIO::TestParallelWrites() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_parallel_writes");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_parallel_writes");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io(instance_);
+  pp::FileIO file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
@@ skipping 59 matching lines @@
     return ReportError("FileIO::Read", rv);
   if (read_buffer != "abcdefghijkl")
     return ReportMismatch("FileIO::Read", read_buffer, "abcdefghijkl");
 
   PASS();
 }
 
 std::string TestFileIO::TestNotAllowMixedReadWrite() {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
-  pp::FileRef_Dev file_ref(file_system, "/file_not_allow_mixed_read_write");
+  pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
+  pp::FileRef file_ref(file_system, "/file_not_allow_mixed_read_write");
   int32_t rv = file_system.Open(1024, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileSystem::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io(instance_);
+  pp::FileIO file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_TRUNCATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
@@ skipping 19 matching lines @@
   if (rv_2 == PP_OK_COMPLETIONPENDING)
     rv_2 = callback_2.WaitForResult();
   if (rv_2 != PP_ERROR_INPROGRESS)
     return ReportError("FileIO::Read", rv_2);
 
   callback_1.WaitForResult();
 
   PASS();
 }
 
-std::string TestFileIO::MatchOpenExpectations(pp::FileSystem_Dev* file_system,
+std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
                                               size_t open_flags,
                                               size_t expectations) {
   std::string bad_argument =
       "TestFileIO::MatchOpenExpectations has invalid input arguments.";
   bool invalid_combination = !!(expectations & INVALID_FLAG_COMBINATION);
   if (invalid_combination) {
     if (expectations != INVALID_FLAG_COMBINATION)
       return bad_argument;
   } else {
     // Validate that one and only one of <some_expectation> and
     // DONT_<some_expectation> is specified.
     for (size_t remains = expectations, end = END_OF_OPEN_EXPECATION_PAIRS;
          end != 0; remains >>= 2, end >>= 2) {
       if (!!(remains & 1) == !!(remains & 2))
         return bad_argument;
     }
   }
   bool create_if_doesnt_exist = !!(expectations & CREATE_IF_DOESNT_EXIST);
   bool open_if_exists = !!(expectations & OPEN_IF_EXISTS);
   bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS);
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  pp::FileRef_Dev existent_file_ref(
+  pp::FileRef existent_file_ref(
       *file_system, "/match_open_expectation_existent_non_empty_file");
-  pp::FileRef_Dev nonexistent_file_ref(
+  pp::FileRef nonexistent_file_ref(
       *file_system, "/match_open_expectation_nonexistent_file");
 
   // Setup files for test.
   {
     int32_t rv = existent_file_ref.Delete(callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("FileRef::Delete force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
       return ReportError("FileRef::Delete", rv);
 
     rv = nonexistent_file_ref.Delete(callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("FileRef::Delete force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK && rv != PP_ERROR_FILENOTFOUND)
       return ReportError("FileRef::Delete", rv);
 
-    pp::FileIO_Dev existent_file_io(instance_);
+    pp::FileIO existent_file_io(instance_);
     rv = existent_file_io.Open(existent_file_ref,
                                PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                                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);
 
     rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io, 0,
                            "foobar");
     if (rv != PP_OK)
       return ReportError("FileIO::Write", rv);
   }
 
-  pp::FileIO_Dev existent_file_io(instance_);
+  pp::FileIO existent_file_io(instance_);
   int32_t rv = existent_file_io.Open(existent_file_ref, open_flags, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if ((invalid_combination && rv == PP_OK) ||
       (!invalid_combination && ((rv == PP_OK) != open_if_exists))) {
     return ReportOpenError(open_flags);
   }
 
   if (!invalid_combination && open_if_exists) {
-    PP_FileInfo_Dev info;
+    PP_FileInfo info;
     rv = existent_file_io.Query(&info, callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("FileIO::Query force_async", rv);
     if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Query", rv);
 
     if (truncate_if_exists != (info.size == 0))
       return ReportOpenError(open_flags);
   }
 
-  pp::FileIO_Dev nonexistent_file_io(instance_);
+  pp::FileIO nonexistent_file_io(instance_);
   rv = nonexistent_file_io.Open(nonexistent_file_ref, open_flags, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("FileIO::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if ((invalid_combination && rv == PP_OK) ||
       (!invalid_combination && ((rv == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
   return std::string();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457