diff options
| -rw-r--r-- | ppapi/tests/test_case.h | 7 | ||||
| -rw-r--r-- | ppapi/tests/test_file_io.cc | 1155 | ||||
| -rw-r--r-- | ppapi/tests/test_url_request.cc | 2 | ||||
| -rw-r--r-- | ppapi/tests/test_utils.h | 16 | ||||
| -rw-r--r-- | ppapi/tests/test_websocket.cc | 2 | ||||
| -rw-r--r-- | ppapi/thunk/enter.cc | 4 |
6 files changed, 714 insertions, 472 deletions
diff --git a/ppapi/tests/test_case.h b/ppapi/tests/test_case.h index e0910f5..b06f941 100644 --- a/ppapi/tests/test_case.h +++ b/ppapi/tests/test_case.h @@ -319,10 +319,9 @@ class TestCaseFactory { // Helper macros for checking values in tests, and returning a location // description of the test fails. #define ASSERT_TRUE(cmd) \ - do { \ - if (!(cmd)) \ - return MakeFailureMessage(__FILE__, __LINE__, #cmd); \ - } while (false) + if (!(cmd)) { \ + return MakeFailureMessage(__FILE__, __LINE__, #cmd); \ + } #define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd)) #define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b)) #define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b)) diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc index 1aae699..9f88f00 100644 --- a/ppapi/tests/test_file_io.cc +++ b/ppapi/tests/test_file_io.cc @@ -62,21 +62,21 @@ std::string ReportOpenError(int32_t open_flags) { int32_t ReadEntireFile(PP_Instance instance, pp::FileIO* file_io, int32_t offset, - std::string* data, - CallbackType callback_type) { - TestCompletionCallback callback(instance, callback_type); + std::string* data) { + TestCompletionCallback callback(instance); char buf[256]; int32_t read_offset = offset; for (;;) { - callback.WaitForResult( - file_io->Read(read_offset, buf, sizeof(buf), callback)); - if (callback.result() < 0) - return callback.result(); - if (callback.result() == 0) + 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 += callback.result(); - data->append(buf, callback.result()); + read_offset += rv; + data->append(buf, rv); } return PP_OK; @@ -86,9 +86,9 @@ int32_t ReadToArrayEntireFile(PP_Instance instance, pp::FileIO* file_io, int32_t offset, std::string* data, - CallbackType callback_type) { + bool force_async) { TestCompletionCallbackWithOutput< std::vector<char> > callback( - instance, callback_type); + instance, force_async); for (;;) { callback.WaitForResult(file_io->Read(offset, 256, callback)); @@ -108,23 +108,22 @@ int32_t ReadToArrayEntireFile(PP_Instance instance, int32_t WriteEntireBuffer(PP_Instance instance, pp::FileIO* file_io, int32_t offset, - const std::string& data, - CallbackType callback_type) { - TestCompletionCallback callback(instance, callback_type); + 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) { - callback.WaitForResult(file_io->Write(write_offset, - &buf[write_offset - offset], - size - write_offset + offset, - callback)); - if (callback.result() < 0) - return callback.result(); - if (callback.result() == 0) + int32_t rv = file_io->Write(write_offset, &buf[write_offset - offset], + size - write_offset + offset, callback); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv < 0) + return rv; + if (rv == 0) return PP_ERROR_FAILED; - write_offset += callback.result(); + write_offset += rv; } return PP_OK; @@ -137,15 +136,15 @@ bool TestFileIO::Init() { } void TestFileIO::RunTests(const std::string& filter) { - RUN_CALLBACK_TEST(TestFileIO, Open, filter); - RUN_CALLBACK_TEST(TestFileIO, ReadWriteSetLength, filter); - RUN_CALLBACK_TEST(TestFileIO, ReadToArrayWriteSetLength, filter); - RUN_CALLBACK_TEST(TestFileIO, TouchQuery, filter); - RUN_CALLBACK_TEST(TestFileIO, AbortCalls, filter); - RUN_CALLBACK_TEST(TestFileIO, ParallelReads, filter); - RUN_CALLBACK_TEST(TestFileIO, ParallelWrites, filter); - RUN_CALLBACK_TEST(TestFileIO, NotAllowMixedReadWrite, filter); - RUN_CALLBACK_TEST(TestFileIO, WillWriteWillSetLength, filter); + RUN_TEST_FORCEASYNC_AND_NOT(Open, filter); + RUN_TEST_FORCEASYNC_AND_NOT(ReadWriteSetLength, filter); + RUN_TEST_FORCEASYNC_AND_NOT(ReadToArrayWriteSetLength, filter); + RUN_TEST_FORCEASYNC_AND_NOT(TouchQuery, filter); + RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls, filter); + RUN_TEST_FORCEASYNC_AND_NOT(ParallelReads, filter); + RUN_TEST_FORCEASYNC_AND_NOT(ParallelWrites, filter); + RUN_TEST_FORCEASYNC_AND_NOT(NotAllowMixedReadWrite, filter); + RUN_TEST_FORCEASYNC_AND_NOT(WillWriteWillSetLength, filter); // TODO(viettrungluu): add tests: // - that PP_ERROR_PENDING is correctly returned @@ -153,13 +152,17 @@ void TestFileIO::RunTests(const std::string& filter) { } std::string TestFileIO::TestOpen() { - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_open"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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( @@ -247,106 +250,133 @@ std::string TestFileIO::TestOpen() { } std::string TestFileIO::TestReadWriteSetLength() { - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_read_write_setlength"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); // Write something to the file. - int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, - "test_test", callback_type()); - ASSERT_EQ(PP_OK, rv); + rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test"); + if (rv != PP_OK) + return ReportError("FileIO::Write", rv); - // Attempt to read a negative number of bytes; it should fail. + // Check for failing read operation. char buf[256]; - callback.WaitForResult(file_io.Read(0, - buf, - -1, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_ERROR_FAILED, callback.result()); + rv = file_io.Read(0, buf, -1, // negative number of bytes to read + callback); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_ERROR_FAILED) + return ReportError("FileIO::Read", rv); // Read the entire file. std::string read_buffer; - rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test_test"), 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. - callback.WaitForResult(file_io.SetLength(4, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + rv = file_io.SetLength(4, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::SetLength force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("FileIO::SetLength", rv); // Check the file contents. read_buffer.clear(); - rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test"), 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(instance_->pp_instance(), &file_io, 100, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_TRUE(read_buffer.empty()); + 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(instance_->pp_instance(), &file_io, 8, "test", - callback_type()); - ASSERT_EQ(PP_OK, rv); + 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(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test\0\0\0\0test", 12), 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. - callback.WaitForResult(file_io.SetLength(16, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + rv = file_io.SetLength(16, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::SetLength force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("FileIO::SetLength", rv); // Check the contents of the file. read_buffer.clear(); - rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), 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(instance_->pp_instance(), &file_io, 4, "test", - callback_type()); - ASSERT_EQ(PP_OK, rv); + 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(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), 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(instance_->pp_instance(), &file_io, 4, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("testtest\0\0\0\0", 12), 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(); } @@ -355,149 +385,201 @@ std::string TestFileIO::TestReadWriteSetLength() { // API. With this test case, we can make sure the two Read's have the same // behavior. std::string TestFileIO::TestReadToArrayWriteSetLength() { - if (callback_type() == PP_BLOCKING) { - // This test does not make sense for blocking callbacks. - PASS(); - } - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_read_write_setlength"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); // Write something to the file. - int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, - "test_test", callback_type()); - ASSERT_EQ(PP_OK, rv); + rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test"); + if (rv != PP_OK) + return ReportError("FileIO::Write", rv); TestCompletionCallbackWithOutput< std::vector<char> > callback2( - instance_->pp_instance(), callback_type()); - // Attempt to read a negative number of bytes; it should fail. - callback2.WaitForResult(file_io.Read(0, -1, callback2)); + instance_->pp_instance(), force_async_); + // Check for failing read operation. + callback2.WaitForResult( + file_io.Read(0, -1, // negative number of bytes to read + callback2)); CHECK_CALLBACK_BEHAVIOR(callback2); - ASSERT_EQ(PP_ERROR_FAILED, callback2.result()); + if (callback2.result() != PP_ERROR_FAILED) + return ReportError("FileIO::Read", callback2.result()); // Read the entire file. std::string read_buffer; read_buffer.reserve(10); rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test_test"), read_buffer); + &read_buffer, force_async_); + 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. - callback.WaitForResult(file_io.SetLength(4, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, rv); + rv = file_io.SetLength(4, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::SetLength force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("FileIO::SetLength", rv); // Check the file contents. read_buffer.clear(); rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test"), read_buffer); + &read_buffer, force_async_); + 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 = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 100, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_TRUE(read_buffer.empty()); + &read_buffer, force_async_); + 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(instance_->pp_instance(), &file_io, 8, "test", - callback_type()); - ASSERT_EQ(PP_OK, rv); + 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 = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test\0\0\0\0test", 12), read_buffer); + &read_buffer, force_async_); + 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. - callback.WaitForResult(file_io.SetLength(16, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + rv = file_io.SetLength(16, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::SetLength force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("FileIO::SetLength", rv); // Check the contents of the file. read_buffer.clear(); rv = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test\0\0\0\0test\0\0\0\0", 16), read_buffer); + &read_buffer, force_async_); + 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(instance_->pp_instance(), &file_io, 4, "test", - callback_type()); - ASSERT_EQ(PP_OK, rv); + 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 = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("testtesttest\0\0\0\0", 16), read_buffer); + &read_buffer, force_async_); + 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 = ReadToArrayEntireFile(instance_->pp_instance(), &file_io, 4, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("testtest\0\0\0\0", 12), read_buffer); + &read_buffer, force_async_); + 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(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_ref(file_system, "/file_touch"); pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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) + return ReportError("FileIO::Open", rv); // Write some data to have a non-zero file size. - callback.WaitForResult(file_io.Write(0, "test", 4, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(4, callback.result()); + rv = file_io.Write(0, "test", 4, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Write force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != 4) + return ReportError("FileIO::Write", rv); // last_access_time's granularity is 1 day // last_modified_time's granularity is 2 seconds const PP_Time last_access_time = 123 * 24 * 3600.0; const PP_Time last_modified_time = 246.0; - callback.WaitForResult(file_io.Touch(last_access_time, last_modified_time, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 info; - callback.WaitForResult(file_io.Query(&info, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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) || @@ -507,75 +589,99 @@ std::string TestFileIO::TestTouchQuery() { return "FileIO::Query() has returned bad data."; // Call |Query()| again, to make sure it works a second time. - callback.WaitForResult(file_io.Query(&info, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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); PASS(); } std::string TestFileIO::TestAbortCalls() { - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_abort_calls"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - - int32_t rv = PP_ERROR_FAILED; - // First, create a file on which to do ops. + 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 file_io(instance_); - callback.WaitForResult( - file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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", callback_type()); - ASSERT_EQ(PP_OK, rv); + 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(instance_) - .Open(file_ref, PP_FILEOPENFLAG_READ, callback); + .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); + } } - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) - ASSERT_EQ(callback.result(), PP_OK); - else - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); // Abort |Query()|. { PP_FileInfo info = { 0 }; - // Save a copy and make sure |info| doesn't get written to if it is aborted. - PP_FileInfo info_copy; - memcpy(&info_copy, &info, sizeof(info)); { pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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|. - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) { - ASSERT_EQ(callback.result(), PP_OK); - // The operation completed synchronously, so |info| should have changed. - ASSERT_NE(0, memcmp(&info_copy, &info, sizeof(info))); - } else { - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); - ASSERT_EQ(0, memcmp(&info_copy, &info, sizeof(info))); + if (rv == PP_OK_COMPLETIONPENDING) { + // Save a copy and make sure |info| doesn't get written to. + 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); } } @@ -583,19 +689,26 @@ std::string TestFileIO::TestAbortCalls() { { { pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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|. - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) - ASSERT_EQ(callback.result(), PP_OK); - else - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); + 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()|. @@ -603,23 +716,30 @@ std::string TestFileIO::TestAbortCalls() { char buf[3] = { 0 }; { pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Read force_async", rv); } // Destroy |file_io|. - // Save a copy to make sure buf isn't written to in the async case. - char buf_copy[3]; - memcpy(&buf_copy, &buf, sizeof(buf)); - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) { - ASSERT_EQ(callback.result(), sizeof(buf)); - } else { - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); - ASSERT_EQ(0, memcmp(&buf_copy, &buf, sizeof(buf))); + if (rv == PP_OK_COMPLETIONPENDING) { + // 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); } } @@ -628,38 +748,51 @@ std::string TestFileIO::TestAbortCalls() { char buf[3] = { 0 }; { pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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|. - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) - ASSERT_EQ(callback.result(), sizeof(buf)); - else - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_READ, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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|. - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) { - ASSERT_EQ(callback.result(), PP_OK); - } else { - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); + 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); } } @@ -667,19 +800,25 @@ std::string TestFileIO::TestAbortCalls() { { { pp::FileIO file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - + 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); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Flush force_async", rv); } // Destroy |file_io|. - callback.WaitForResult(rv); - CHECK_CALLBACK_BEHAVIOR(callback); - if (callback_type() == PP_BLOCKING) { - ASSERT_EQ(callback.result(), PP_OK); - } else { - ASSERT_EQ(callback.result(), PP_ERROR_ABORTED); + if (rv == PP_OK_COMPLETIONPENDING) { + rv = callback.WaitForResult(); + if (rv != PP_ERROR_ABORTED) + return "FileIO::Flush not aborted."; + } else if (rv != PP_OK) { + return ReportError("FileIO::Flush", rv); } } @@ -690,33 +829,41 @@ std::string TestFileIO::TestAbortCalls() { } std::string TestFileIO::TestParallelReads() { - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_parallel_reads"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); // Set up testing contents. - int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, - "abcdefghijkl", callback_type()); - ASSERT_EQ(PP_OK, rv); + rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "abcdefghijkl"); + if (rv != PP_OK) + return ReportError("FileIO::Write", rv); // Parallel read operations. const char* border = "__border__"; const int32_t border_size = strlen(border); - TestCompletionCallback callback_1(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback_1(instance_->pp_instance(), force_async_); int32_t read_offset_1 = 0; int32_t size_1 = 3; std::vector<char> extended_buf_1(border_size * 2 + size_1); @@ -724,7 +871,7 @@ std::string TestFileIO::TestParallelReads() { memcpy(&extended_buf_1[0], border, border_size); memcpy(buf_1 + size_1, border, border_size); - TestCompletionCallback callback_2(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback_2(instance_->pp_instance(), force_async_); int32_t read_offset_2 = size_1; int32_t size_2 = 9; std::vector<char> extended_buf_2(border_size * 2 + size_2); @@ -735,68 +882,91 @@ std::string TestFileIO::TestParallelReads() { int32_t rv_1 = PP_OK; int32_t rv_2 = PP_OK; while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) { - if (size_1 > 0) + if (size_1 > 0) { rv_1 = file_io.Read(read_offset_1, buf_1, size_1, callback_1); - if (size_2 > 0) + if (rv_1 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Read", rv_1); + } + + if (size_2 > 0) { rv_2 = file_io.Read(read_offset_2, buf_2, size_2, callback_2); + if (rv_2 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Read", rv_2); + } + if (size_1 > 0) { - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); - ASSERT_TRUE(callback_1.result() > 0); - read_offset_1 += callback_1.result(); - buf_1 += callback_1.result(); - size_1 -= callback_1.result(); + rv_1 = callback_1.WaitForResult(); + if (rv_1 <= 0) + return ReportError("FileIO::Read", rv_1); + read_offset_1 += rv_1; + buf_1 += rv_1; + size_1 -= rv_1; } if (size_2 > 0) { - callback_2.WaitForResult(rv_2); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_TRUE(callback_2.result() > 0); - read_offset_2 += callback_2.result(); - buf_2 += callback_2.result(); - size_2 -= callback_2.result(); + rv_2 = callback_2.WaitForResult(); + if (rv_2 <= 0) + return ReportError("FileIO::Read", rv_2); + read_offset_2 += rv_2; + buf_2 += rv_2; + size_2 -= rv_2; } } - // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s). - ASSERT_EQ(0, size_1); - ASSERT_EQ(0, size_2); + // If |size_1| or |size_2| is less than 0, we have invoked wrong + // callback(s). + if (size_1 < 0 || size_2 < 0) { + return std::string( + "Parallel FileIO::Read operations have invoked wrong callbacks."); + } // Make sure every read operation writes into the correct buffer. const char expected_result_1[] = "__border__abc__border__"; const char expected_result_2[] = "__border__defghijkl__border__"; - ASSERT_TRUE(strncmp(&extended_buf_1[0], expected_result_1, - strlen(expected_result_1)) == 0); - ASSERT_TRUE(strncmp(&extended_buf_2[0], expected_result_2, - strlen(expected_result_2)) == 0); + if (strncmp(&extended_buf_1[0], expected_result_1, + strlen(expected_result_1)) != 0 || + strncmp(&extended_buf_2[0], expected_result_2, + strlen(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(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_parallel_writes"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); // Parallel write operations. - TestCompletionCallback callback_1(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback_1(instance_->pp_instance(), force_async_); int32_t write_offset_1 = 0; const char* buf_1 = "abc"; int32_t size_1 = strlen(buf_1); - TestCompletionCallback callback_2(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback_2(instance_->pp_instance(), force_async_); int32_t write_offset_2 = size_1; const char* buf_2 = "defghijkl"; int32_t size_2 = strlen(buf_2); @@ -804,181 +974,227 @@ std::string TestFileIO::TestParallelWrites() { int32_t rv_1 = PP_OK; int32_t rv_2 = PP_OK; while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) { - if (size_1 > 0) + if (size_1 > 0) { rv_1 = file_io.Write(write_offset_1, buf_1, size_1, callback_1); - if (size_2 > 0) + if (rv_1 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Write", rv_1); + } + + if (size_2 > 0) { rv_2 = file_io.Write(write_offset_2, buf_2, size_2, callback_2); + if (rv_2 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Write", rv_2); + } if (size_1 > 0) { - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); - ASSERT_TRUE(callback_1.result() > 0); - write_offset_1 += callback_1.result(); - buf_1 += callback_1.result(); - size_1 -= callback_1.result(); + rv_1 = callback_1.WaitForResult(); + if (rv_1 <= 0) + return ReportError("FileIO::Write", rv_1); + write_offset_1 += rv_1; + buf_1 += rv_1; + size_1 -= rv_1; } if (size_2 > 0) { - callback_2.WaitForResult(rv_2); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_TRUE(callback_2.result() > 0); - write_offset_2 += callback_2.result(); - buf_2 += callback_2.result(); - size_2 -= callback_2.result(); + rv_2 = callback_2.WaitForResult(); + if (rv_2 <= 0) + return ReportError("FileIO::Write", rv_2); + write_offset_2 += rv_2; + buf_2 += rv_2; + size_2 -= rv_2; } } - // If |size_1| or |size_2| is not 0, we have invoked wrong callback(s). - ASSERT_EQ(0, size_1); - ASSERT_EQ(0, size_2); + // If |size_1| or |size_2| is less than 0, we have invoked wrong + // callback(s). + if (size_1 < 0 || size_2 < 0) { + return std::string( + "Parallel FileIO::Write operations have invoked wrong callbacks."); + } // Check the file contents. std::string read_buffer; - int32_t rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, - &read_buffer, callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("abcdefghijkl"), read_buffer); + rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer); + if (rv != PP_OK) + return ReportError("FileIO::Read", rv); + if (read_buffer != "abcdefghijkl") + return ReportMismatch("FileIO::Read", read_buffer, "abcdefghijkl"); PASS(); } std::string TestFileIO::TestNotAllowMixedReadWrite() { - if (callback_type() == PP_BLOCKING) { - // This test does not make sense for blocking callbacks. - PASS(); - } - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_not_allow_mixed_read_write"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - - TestCompletionCallback callback_1(instance_->pp_instance(), callback_type()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); + + // Cannot read and write in parallel. + TestCompletionCallback callback_1(instance_->pp_instance(), force_async_); int32_t write_offset_1 = 0; const char* buf_1 = "mnopqrstuvw"; int32_t rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1); - ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1); + if (rv_1 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Write", rv_1); - TestCompletionCallback callback_2(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback_2(instance_->pp_instance(), force_async_); int32_t read_offset_2 = 4; char buf_2[3]; - callback_2.WaitForResult(file_io.Read(read_offset_2, buf_2, sizeof(buf_2), - callback_2)); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result()); - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); + int32_t rv_2 = file_io.Read(read_offset_2, buf_2, sizeof(buf_2), + callback_2); + if (force_async_ && rv_2 != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::Read force_async", rv_2); + 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(); // Cannot query while a write is pending. rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1); ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1); + TestCompletionCallback callback_3(instance_->pp_instance(), force_async_); PP_FileInfo info; - callback_2.WaitForResult(file_io.Query(&info, callback_2)); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result()); - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); + 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); + callback_1.WaitForResult(); // Cannot touch while a write is pending. rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1); ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1); - callback_2.WaitForResult(file_io.Touch(1234.0, 5678.0, callback_2)); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result()); - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); + 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); + callback_1.WaitForResult(); // Cannot set length while a write is pending. rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1), callback_1); ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1); - callback_2.WaitForResult(file_io.SetLength(123, callback_2)); - CHECK_CALLBACK_BEHAVIOR(callback_2); - ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result()); - callback_1.WaitForResult(rv_1); - CHECK_CALLBACK_BEHAVIOR(callback_1); + 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(); } std::string TestFileIO::TestWillWriteWillSetLength() { - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY); pp::FileRef file_ref(file_system, "/file_will_write"); - callback.WaitForResult(file_system.Open(1024, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 file_io(instance_); - callback.WaitForResult(file_io.Open(file_ref, - PP_FILEOPENFLAG_CREATE | - PP_FILEOPENFLAG_TRUNCATE | - PP_FILEOPENFLAG_READ | - PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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(); + if (rv != PP_OK) + return ReportError("FileIO::Open", rv); const PPB_FileIOTrusted* trusted = static_cast<const PPB_FileIOTrusted*>( pp::Module::Get()->GetBrowserInterface(PPB_FILEIOTRUSTED_INTERFACE)); - ASSERT_TRUE(trusted); + 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()); - ASSERT_TRUE(fd >= 0); + if (fd < 0) + return "FileIO::GetOSFileDescriptor() returned a bad file descriptor."; } // Calling WillWrite. - callback.WaitForResult(trusted->WillWrite( + rv = trusted->WillWrite( file_io.pp_resource(), 0, 9, - callback.GetCallback().pp_completion_callback())); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(9, callback.result()); + static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != 9) + return ReportError("WillWrite", rv); // Writing the actual data. - int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, - "test_test", callback_type()); - ASSERT_EQ(PP_OK, rv); + rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0, "test_test"); + if (rv != PP_OK) + return ReportError("FileIO::Write", rv); std::string read_buffer; - rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test_test"), 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"); // Calling WillSetLength. - callback.WaitForResult(trusted->WillSetLength( + rv = trusted->WillSetLength( file_io.pp_resource(), 4, - callback.GetCallback().pp_completion_callback())); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, rv); + static_cast<pp::CompletionCallback>(callback).pp_completion_callback()); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("WillSetLength", rv); // Calling actual SetLength. - callback.WaitForResult(file_io.SetLength(4, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, rv); + rv = file_io.SetLength(4, callback); + if (force_async_ && rv != PP_OK_COMPLETIONPENDING) + return ReportError("FileIO::SetLength force_async", rv); + if (rv == PP_OK_COMPLETIONPENDING) + rv = callback.WaitForResult(); + if (rv != PP_OK) + return ReportError("FileIO::SetLength", rv); read_buffer.clear(); - rv = ReadEntireFile(instance_->pp_instance(), &file_io, 0, &read_buffer, - callback_type()); - ASSERT_EQ(PP_OK, rv); - ASSERT_EQ(std::string("test"), 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"); PASS(); } @@ -1005,7 +1221,7 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system, bool open_if_exists = !!(expectations & OPEN_IF_EXISTS); bool truncate_if_exists = !!(expectations & TRUNCATE_IF_EXISTS); - TestCompletionCallback callback(instance_->pp_instance(), callback_type()); + TestCompletionCallback callback(instance_->pp_instance(), force_async_); pp::FileRef existent_file_ref( *file_system, "/match_open_expectation_existent_non_empty_file"); pp::FileRef nonexistent_file_ref( @@ -1013,53 +1229,72 @@ std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system, // Setup files for test. { - callback.WaitForResult(existent_file_ref.Delete(callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_TRUE(callback.result() == PP_OK || - callback.result() == PP_ERROR_FILENOTFOUND); - callback.WaitForResult(nonexistent_file_ref.Delete(callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_TRUE(callback.result() == PP_OK || - callback.result() == PP_ERROR_FILENOTFOUND); + 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 existent_file_io(instance_); - callback.WaitForResult(existent_file_io.Open( - existent_file_ref, - PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); - int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &existent_file_io, - 0, "foobar", callback_type()); - ASSERT_EQ(PP_OK, rv); + 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 existent_file_io(instance_); - callback.WaitForResult(existent_file_io.Open(existent_file_ref, open_flags, - callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - if ((invalid_combination && callback.result() == PP_OK) || - (!invalid_combination && - ((callback.result() == PP_OK) != open_if_exists))) { + 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 info; - callback.WaitForResult(existent_file_io.Query(&info, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - ASSERT_EQ(PP_OK, callback.result()); + 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 nonexistent_file_io(instance_); - callback.WaitForResult(nonexistent_file_io.Open(nonexistent_file_ref, - open_flags, callback)); - CHECK_CALLBACK_BEHAVIOR(callback); - if ((invalid_combination && callback.result() == PP_OK) || - (!invalid_combination && - ((callback.result() == PP_OK) != create_if_doesnt_exist))) { + 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); } diff --git a/ppapi/tests/test_url_request.cc b/ppapi/tests/test_url_request.cc index fd904db..00e6d2e 100644 --- a/ppapi/tests/test_url_request.cc +++ b/ppapi/tests/test_url_request.cc @@ -111,7 +111,7 @@ std::string TestURLRequest::TestCreateAndIsURLRequestInfo() { // IsURLRequestInfo: Released URLRequestInfo resource -> false. ppb_core_interface_->ReleaseResource(url_request); - ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request)); + ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request)) return error; // == PASS() if empty. } diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h index 0869be6..09e0b94 100644 --- a/ppapi/tests/test_utils.h +++ b/ppapi/tests/test_utils.h @@ -178,14 +178,14 @@ class TestCompletionCallbackWithOutput : public TestCompletionCallback { explicit TestCompletionCallbackWithOutput(PP_Instance instance) : TestCompletionCallback(instance) { } - // We purposely don't define a force_async constructor, since force_async - // is going away. TODO(dmichael): remove this comment with force_async. + + TestCompletionCallbackWithOutput(PP_Instance instance, bool force_async) : + TestCompletionCallback(instance, force_async) { + } TestCompletionCallbackWithOutput(PP_Instance instance, CallbackType callback_type) : TestCompletionCallback(instance, callback_type) { - // Callbacks with output don't make sense for blocking calls. - PP_DCHECK(callback_type != PP_BLOCKING); } pp::CompletionCallbackWithOutput<OutputT> GetCallbackWithOutput(); @@ -203,6 +203,14 @@ template <typename OutputT> pp::CompletionCallbackWithOutput<OutputT> TestCompletionCallbackWithOutput<OutputT>::GetCallbackWithOutput() { Reset(); + if (callback_type_ == PP_BLOCKING) { + pp::CompletionCallbackWithOutput<OutputT> cc( + &TestCompletionCallback::Handler, + this, + &output_storage_); + return cc; + } + target_loop_ = pp::MessageLoop::GetCurrent(); pp::CompletionCallbackWithOutput<OutputT> cc( &TestCompletionCallback::Handler, diff --git a/ppapi/tests/test_websocket.cc b/ppapi/tests/test_websocket.cc index 56d6d84..d5dc486 100644 --- a/ppapi/tests/test_websocket.cc +++ b/ppapi/tests/test_websocket.cc @@ -1350,7 +1350,7 @@ std::string TestWebSocket::TestUtilityValidClose() { ASSERT_EQ(PP_ERROR_INPROGRESS, result); websocket.WaitForClosed(); const std::vector<WebSocketEvent>& events = websocket.GetSeenEvents(); - ASSERT_TRUE(events.size() == 2 || events.size() == 3); + ASSERT_TRUE(events.size() == 2 || events.size() == 3) int index = 0; if (events.size() == 3) ASSERT_EQ(WebSocketEvent::EVENT_OPEN, events[index++].event_type); diff --git a/ppapi/thunk/enter.cc b/ppapi/thunk/enter.cc index 030b945..296a8b4 100644 --- a/ppapi/thunk/enter.cc +++ b/ppapi/thunk/enter.cc @@ -133,8 +133,8 @@ void EnterBase::SetStateForCallbackError(bool report_error) { // the plugin won't expect any return code other than // PP_OK_COMPLETIONPENDING. So we crash to make the problem more obvious. if (callback_->is_required()) { - std::string message("Attempted to use a required callback, but there " - "is no attached message loop on which to run the " + std::string message("Attempted to use a required callback, but there" + "is no attached message loop on which to run the" "callback."); PpapiGlobals::Get()->BroadcastLogWithSource(0, PP_LOGLEVEL_ERROR, std::string(), message); |