Fix FileIO and FileRef PPAPI tests to match changes in

ppapi/tests/test_file_ref.cc

 // Copyright (c) 2010 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_ref.h"
 
 #include <stdio.h>
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/dev/ppb_file_io_dev.h"
@@ skipping 50 matching lines @@
       instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 
   pp::FileRef_Dev file_ref_pers(file_system_pers, kPersFilePath);
   if (file_ref_pers.GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALPERSISTENT)
     return "file_ref_pers expected to be persistent.";
 
   pp::FileRef_Dev file_ref_temp(file_system_temp, kTempFilePath);
   if (file_ref_temp.GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALTEMPORARY)
     return "file_ref_temp expected to be temporary.";
 
-  pp::URLRequestInfo request;
+  pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
   TestCompletionCallback callback;
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
     return "URLLoader::GetResponseInfo returned null";
   int32_t status_code = response_info.GetStatusCode();
@@ skipping 22 matching lines @@
   name = file_ref_temp.GetName().AsString();
   if (name != kTempFileName)
     return ReportMismatch("FileRef::GetName", name, kTempFileName);
 
   // Test the "/" case.
   pp::FileRef_Dev file_ref_slash(file_system_temp, "/");
   name = file_ref_slash.GetName().AsString();
   if (name != "/")
     return ReportMismatch("FileRef::GetName", name, "/");
 
-  pp::URLRequestInfo request;
+  pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
   TestCompletionCallback callback;
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
     return "URLLoader::GetResponseInfo returned null";
   int32_t status_code = response_info.GetStatusCode();
@@ skipping 17 matching lines @@
   pp::FileRef_Dev file_ref_pers(file_system_pers, kPersFilePath);
   std::string path = file_ref_pers.GetPath().AsString();
   if (path != kPersFilePath)
     return ReportMismatch("FileRef::GetPath", path, kPersFilePath);
 
   pp::FileRef_Dev file_ref_temp(file_system_temp, kTempFilePath);
   path = file_ref_temp.GetPath().AsString();
   if (path != kTempFilePath)
     return ReportMismatch("FileRef::GetPath", path, kTempFilePath);
 
-  pp::URLRequestInfo request;
+  pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
   TestCompletionCallback callback;
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
     return "URLLoader::GetResponseInfo returned null";
   int32_t status_code = response_info.GetStatusCode();
@@ skipping 28 matching lines @@
   parent_path = file_ref_slash.GetParent().GetPath().AsString();
   if (parent_path != "/")
     return ReportMismatch("FileRef::GetParent", parent_path, "/");
 
   // Test the "/foo" case (the parent is "/").
   pp::FileRef_Dev file_ref_with_root_parent(file_system_temp, "/foo");
   parent_path = file_ref_with_root_parent.GetParent().GetPath().AsString();
   if (parent_path != "/")
     return ReportMismatch("FileRef::GetParent", parent_path, "/");
 
-  pp::URLRequestInfo request;
+  pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
   TestCompletionCallback callback;
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
     return "URLLoader::GetResponseInfo returned null";
   int32_t status_code = response_info.GetStatusCode();
@@ skipping 94 matching lines @@
 std::string TestFileRef::TestQueryAndTouchFile() {
   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 63 matching lines @@
 std::string TestFileRef::TestDeleteFileAndDirectory() {
   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_delete");
-  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);
 
   rv = file_ref.Delete(callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
@@ skipping 30 matching lines @@
   pp::FileRef_Dev nonexistent_file_ref(file_system, "/nonexistent_file_delete");
   rv = nonexistent_file_ref.Delete(callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FILENOTFOUND)
     return ReportError("FileSystem::Delete", rv);
 
   // Delete aborted.
   {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_delete_abort");
-    pp::FileIO_Dev file_io_abort;
+    pp::FileIO_Dev file_io_abort(instance_);
     rv = file_io_abort.Open(file_ref_abort, PP_FILEOPENFLAG_CREATE, callback);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
 
     callback.reset_run_count();
     rv = file_ref_abort.Delete(callback);
   }
   if (callback.run_count() > 0)
@@ skipping 12 matching lines @@
 std::string TestFileRef::TestRenameFileAndDirectory() {
   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_rename");
-  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);
 
   pp::FileRef_Dev target_file_ref(file_system, "/target_file_rename");
   rv = file_ref.Rename(target_file_ref, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
@@ skipping 28 matching lines @@
   if (rv != PP_ERROR_FAILED)
     return ReportError("FileSystem::Rename", rv);
 
   // Rename aborted.
   // TODO(viettrungluu): Figure out what we want to do if the target file
   // resource is destroyed before completion.
   pp::FileRef_Dev target_file_ref_abort(file_system,
                                         "/target_file_rename_abort");
   {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_rename_abort");
-    pp::FileIO_Dev file_io_abort;
+    pp::FileIO_Dev file_io_abort(instance_);
     rv = file_io_abort.Open(file_ref_abort, PP_FILEOPENFLAG_CREATE, callback);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
 
     callback.reset_run_count();
     rv = file_ref_abort.Rename(target_file_ref_abort, callback);
   }
   if (callback.run_count() > 0)
     return "FileSystem::Rename ran callback synchronously.";
   if (rv == PP_ERROR_WOULDBLOCK) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Rename not aborted.";
   } else if (rv != PP_OK) {
     return ReportError("FileSystem::Rename", rv);
   }
 
   PASS();
 }