Implement proxy for FlashMenu and Run/QuitMessageLoop

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 11 matching lines @@
 
 namespace {
 
 std::string ReportMismatch(const std::string& method_name,
                            const std::string& returned_result,
                            const std::string& expected_result) {
   return method_name + " returned '" + returned_result + "'; '" +
       expected_result + "' expected.";
 }
 
-int32_t ReadEntireFile(pp::FileIO_Dev* file_io,
+int32_t ReadEntireFile(PP_Instance instance,
+                       pp::FileIO_Dev* file_io,
                        int32_t offset,
                        std::string* data) {
-  TestCompletionCallback callback;
+  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_ERROR_WOULDBLOCK)
       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::FileIO_Dev* file_io,
+int32_t WriteEntireBuffer(PP_Instance instance,
+                          pp::FileIO_Dev* file_io,
                           int32_t offset,
                           const std::string& data) {
-  TestCompletionCallback callback;
+  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);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ skipping 16 matching lines @@
   RUN_TEST(Open);
   RUN_TEST(ReadWriteSetLength);
   RUN_TEST(TouchQuery);
   RUN_TEST(AbortCalls);
   // 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;
+  TestCompletionCallback callback(instance_->pp_instance());
 
   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(instance_);
@@ skipping 10 matching lines @@
       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;
+  TestCompletionCallback callback(instance_->pp_instance());
 
   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(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);
 
   // Write something to the file.
-  rv = WriteEntireBuffer(&file_io, 0, "test_test");
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test");
   if (rv != PP_OK)
     return ReportError("FileIO::Write", rv);
 
   // Read the entire file.
   std::string read_buffer;
-  rv = ReadEntireFile(&file_io, 0, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (read_buffer != "test_test")
     return ReportMismatch("FileIO::Read", read_buffer, "test_test");
 
   // Truncate the file.
   rv = file_io.SetLength(4, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::SetLength", rv);
 
   // Check the file contents.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 0, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (read_buffer != "test")
     return ReportMismatch("FileIO::Read", read_buffer, "test");
 
   // Try to read past the end of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 100, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 100, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (!read_buffer.empty())
     return ReportMismatch("FileIO::Read", read_buffer, "<empty string>");
 
   // Write past the end of the file. The file should be zero-padded.
-  rv = WriteEntireBuffer(&file_io, 8, "test");
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 8, "test");
   if (rv != PP_OK)
     return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 0, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (read_buffer != std::string("test\0\0\0\0test", 12))
     return ReportMismatch("FileIO::Read", read_buffer,
                           std::string("test\0\0\0\0test", 12));
 
   // Extend the file.
   rv = file_io.SetLength(16, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::SetLength", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 0, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (read_buffer != std::string("test\0\0\0\0test\0\0\0\0", 16))
     return ReportMismatch("FileIO::Read", read_buffer,
                           std::string("test\0\0\0\0test\0\0\0\0", 16));
 
   // Write in the middle of the file.
-  rv = WriteEntireBuffer(&file_io, 4, "test");
+  rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 4, "test");
   if (rv != PP_OK)
     return ReportError("FileIO::Write", rv);
 
   // Check the contents of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 0, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   if (read_buffer != std::string("testtesttest\0\0\0\0", 16))
     return ReportMismatch("FileIO::Read", read_buffer,
                           std::string("testtesttest\0\0\0\0", 16));
 
   // Read from the middle of the file.
   read_buffer.clear();
-  rv = ReadEntireFile(&file_io, 4, &read_buffer);
+  rv = ReadEntireFile(instance_->pp_instance(), &file_io, 4, &read_buffer);
   if (rv != PP_OK)
     return ReportError("FileIO::Read", rv);
   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;
+  TestCompletionCallback callback(instance_->pp_instance());
 
   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(instance_);
@@ skipping 40 matching lines @@
   rv = file_io.Query(&info, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Query", rv);
 
   PASS();
 }
 
 std::string TestFileIO::TestAbortCalls() {
-  TestCompletionCallback callback;
+  TestCompletionCallback callback(instance_->pp_instance());
 
   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(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");
+    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_)
         .Open(file_ref, PP_FILEOPENFLAG_READ,callback);
     if (callback.run_count() > 0)
@@ skipping 152 matching lines @@
     }
   }
 
   // TODO(viettrungluu): Also test that Close() aborts callbacks.
   // crbug.com/69457
 
   PASS();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457