Fix FileIO and FileRef PPAPI tests to match changes in

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 "ppapi/c/pp_errors.h"
@@ skipping 83 matching lines @@
   TestCompletionCallback callback;
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_open");
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io;
+  pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
   // Try opening a file that doesn't exist.
   pp::FileRef_Dev nonexistent_file_ref(file_system, "/nonexistent_file");
-  pp::FileIO_Dev nonexistent_file_io;
+  pp::FileIO_Dev nonexistent_file_io(instance_);
   rv = nonexistent_file_io.Open(
       nonexistent_file_ref, PP_FILEOPENFLAG_READ, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FILENOTFOUND)
     return ReportError("FileIO::Open", rv);
 
   PASS();
 }
 
 std::string TestFileIO::TestReadWriteSetLength() {
   TestCompletionCallback callback;
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_read_write_setlength");
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
 
-  pp::FileIO_Dev file_io;
+  pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE |
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
@@ skipping 93 matching lines @@
   TestCompletionCallback callback;
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     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;
+  pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                     callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
   // Write some data to have a non-zero file size.
   rv = file_io.Write(0, "test", 4, callback);
@@ skipping 42 matching lines @@
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   pp::FileRef_Dev file_ref(file_system, "/file_abort_calls");
   int32_t rv = file_system.Open(1024, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     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;
+    pp::FileIO_Dev file_io(instance_);
     rv = file_io.Open(file_ref,
                       PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                       callback);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
 
     // N.B.: Should write at least 3 bytes.
     rv = WriteEntireBuffer(&file_io, 0, "foobarbazquux");
     if (rv != PP_OK)
       return ReportError("FileIO::Write", rv);
   }
 
   // Abort |Open()|.
   {
     callback.reset_run_count();
-    rv = pp::FileIO_Dev().Open(file_ref, PP_FILEOPENFLAG_READ, callback);
+    rv = pp::FileIO_Dev(instance_)
+        .Open(file_ref, PP_FILEOPENFLAG_READ,callback);
     if (callback.run_count() > 0)
       return "FileIO::Open ran callback synchronously.";
     if (rv == PP_ERROR_WOULDBLOCK) {
       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::FileIO_Dev file_io;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
 
       callback.reset_run_count();
       rv = file_io.Query(&info, callback);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       // Save a copy and make sure |info| doesn't get written to.
       PP_FileInfo_Dev 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;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
 
       callback.reset_run_count();
       rv = file_io.Touch(0, 0, callback);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       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;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         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);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       // Save a copy and make sure |buf| doesn't get written to.
       char buf_copy[3];
       memcpy(&buf_copy, &buf, sizeof(buf));
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Read not aborted.";
       if (memcmp(&buf_copy, &buf, sizeof(buf)) != 0)
         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;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         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);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       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;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
 
       callback.reset_run_count();
       rv = file_io.SetLength(3, callback);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       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;
+      pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
       if (rv == PP_ERROR_WOULDBLOCK)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
 
       callback.reset_run_count();
       rv = file_io.Flush(callback);
     }  // Destroy |file_io|.
     if (rv == PP_ERROR_WOULDBLOCK) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Flush not aborted.";
     } else if (rv != PP_OK) {
       return ReportError("FileIO::Flush", rv);
     }
   }
 
   // TODO(viettrungluu): Also test that Close() aborts callbacks.
   // crbug.com/69457
 
   PASS();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457