1;2cReplace PP_ERROR_WOULDBLOCK with PP_OK_COMPLETIONPENDING. Improve error code comments. Update all code that uses this error code. Keep the old code for now flagging it as deprecated. Update copyrights.

BUG=none
TEST=bots
Review URL: http://codereview.chromium.org/6814033

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@81168 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 105 insertions, 105 deletions

diff --git a/ppapi/tests/test_directory_reader.cc b/ppapi/tests/test_directory_reader.cc
index 45e9a99..8fa3794 100644
--- a/ppapi/tests/test_directory_reader.cc
+++ b/ppapi/tests/test_directory_reader.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -44,7 +44,7 @@ std::string TestDirectoryReader::TestGetNextFile() {
   pp::FileSystem_Dev file_system(
       instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -56,19 +56,19 @@ std::string TestDirectoryReader::TestGetNextFile() {
 
   pp::FileIO_Dev file_io_1;
   rv = file_io_1.Open(file_ref_1, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
   pp::FileIO_Dev file_io_2;
   rv = file_io_2.Open(file_ref_2, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
   pp::FileIO_Dev file_io_3;
   rv = file_io_3.Open(file_ref_3, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
@@ -77,17 +77,17 @@ std::string TestDirectoryReader::TestGetNextFile() {
   pp::FileRef_Dev dir_ref_2(file_system, "/dir_2");
   pp::FileRef_Dev dir_ref_3(file_system, "/dir_3");
   rv = dir_ref_1.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileRef::MakeDirectory", rv);
   rv = dir_ref_2.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileRef::MakeDirectory", rv);
   rv = dir_ref_3.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileRef::MakeDirectory", rv);
@@ -98,7 +98,7 @@ std::string TestDirectoryReader::TestGetNextFile() {
     pp::DirectoryEntry_Dev entry;
     do {
       rv = directory_reader.GetNextEntry(&entry, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("DirectoryReader::GetNextEntry", rv);
@@ -156,7 +156,7 @@ std::string TestDirectoryReader::TestGetNextFile() {
     // If |GetNextEntry()| is completing asynchronously, the callback should be
     // aborted (i.e., called with |PP_ERROR_ABORTED| from the message loop)
     // since the resource was destroyed.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       // |GetNextEntry()| *may* have written to |entry| (e.g., synchronously,
       // before the resource was destroyed), but it must not write to it after
       // destruction.
diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc
index 4a7278f..53a441b 100644
--- a/ppapi/tests/test_file_io.cc
+++ b/ppapi/tests/test_file_io.cc
@@ -39,7 +39,7 @@ int32_t ReadEntireFile(PP_Instance instance,
 
   for (;;) {
     int32_t rv = file_io->Read(read_offset, buf, sizeof(buf), callback);
-    if (rv == PP_ERROR_WOULDBLOCK)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return rv;
@@ -64,7 +64,7 @@ int32_t WriteEntireBuffer(PP_Instance instance,
   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)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return rv;
@@ -98,14 +98,14 @@ std::string TestFileIO::TestOpen() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     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, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
@@ -115,7 +115,7 @@ std::string TestFileIO::TestOpen() {
   pp::FileIO_Dev nonexistent_file_io(instance_);
   rv = nonexistent_file_io.Open(
       nonexistent_file_ref, PP_FILEOPENFLAG_READ, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FILENOTFOUND)
     return ReportError("FileIO::Open", rv);
@@ -129,7 +129,7 @@ std::string TestFileIO::TestReadWriteSetLength() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -140,7 +140,7 @@ std::string TestFileIO::TestReadWriteSetLength() {
                     PP_FILEOPENFLAG_READ |
                     PP_FILEOPENFLAG_WRITE,
                     callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
@@ -160,7 +160,7 @@ std::string TestFileIO::TestReadWriteSetLength() {
 
   // Truncate the file.
   rv = file_io.SetLength(4, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::SetLength", rv);
@@ -197,7 +197,7 @@ std::string TestFileIO::TestReadWriteSetLength() {
 
   // Extend the file.
   rv = file_io.SetLength(16, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::SetLength", rv);
@@ -242,7 +242,7 @@ std::string TestFileIO::TestTouchQuery() {
 
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -252,14 +252,14 @@ std::string TestFileIO::TestTouchQuery() {
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                     callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  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.
   rv = file_io.Write(0, "test", 4, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != 4)
     return ReportError("FileIO::Write", rv);
@@ -269,14 +269,14 @@ std::string TestFileIO::TestTouchQuery() {
   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 (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Touch", rv);
 
   PP_FileInfo_Dev info;
   rv = file_io.Query(&info, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Query", rv);
@@ -290,7 +290,7 @@ std::string TestFileIO::TestTouchQuery() {
 
   // Call |Query()| again, to make sure it works a second time.
   rv = file_io.Query(&info, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Query", rv);
@@ -304,7 +304,7 @@ std::string TestFileIO::TestAbortCalls() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -315,7 +315,7 @@ std::string TestFileIO::TestAbortCalls() {
     rv = file_io.Open(file_ref,
                       PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                       callback);
-    if (rv == PP_ERROR_WOULDBLOCK)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
@@ -336,7 +336,7 @@ std::string TestFileIO::TestAbortCalls() {
         .Open(file_ref, PP_FILEOPENFLAG_READ,callback);
     if (callback.run_count() > 0)
       return "FileIO::Open ran callback synchronously.";
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Open not aborted.";
@@ -351,7 +351,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -359,7 +359,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.Query(&info, callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |info| doesn't get written to.
       PP_FileInfo_Dev info_copy;
       memcpy(&info_copy, &info, sizeof(info));
@@ -378,7 +378,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_WRITE, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -386,7 +386,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.Touch(0, 0, callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Touch not aborted.";
@@ -401,7 +401,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -409,7 +409,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.Read(0, buf, sizeof(buf), callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    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));
@@ -429,7 +429,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -437,7 +437,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.Write(0, buf, sizeof(buf), callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Write not aborted.";
@@ -451,7 +451,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -459,7 +459,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.SetLength(3, callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::SetLength not aborted.";
@@ -473,7 +473,7 @@ std::string TestFileIO::TestAbortCalls() {
     {
       pp::FileIO_Dev file_io(instance_);
       rv = file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("FileIO::Open", rv);
@@ -481,7 +481,7 @@ std::string TestFileIO::TestAbortCalls() {
       callback.reset_run_count();
       rv = file_io.Flush(callback);
     }  // Destroy |file_io|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "FileIO::Flush not aborted.";
diff --git a/ppapi/tests/test_file_ref.cc b/ppapi/tests/test_file_ref.cc
index 1596333..c448927 100644
--- a/ppapi/tests/test_file_ref.cc
+++ b/ppapi/tests/test_file_ref.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -76,7 +76,7 @@ std::string TestFileRef::TestGetFileSystemType() {
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
@@ -125,7 +125,7 @@ std::string TestFileRef::TestGetName() {
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
@@ -169,7 +169,7 @@ std::string TestFileRef::TestGetPath() {
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
@@ -224,7 +224,7 @@ std::string TestFileRef::TestGetParent() {
 
   pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return "URLLoader::Open() failed.";
@@ -249,7 +249,7 @@ std::string TestFileRef::TestMakeDirectory() {
   // Open.
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -257,7 +257,7 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectory.
   pp::FileRef_Dev dir_ref(file_system, "/test_dir_make_directory");
   rv = dir_ref.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectory", rv);
@@ -268,7 +268,7 @@ std::string TestFileRef::TestMakeDirectory() {
       .MakeDirectory(callback);
   if (callback.run_count() > 0)
     return "FileSystem::MakeDirectory ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::MakeDirectory not aborted.";
@@ -279,7 +279,7 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectoryIncludingAncestors.
   dir_ref = pp::FileRef_Dev(file_system, "/dir_make_dir_1/dir_make_dir_2");
   rv = dir_ref.MakeDirectoryIncludingAncestors(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectoryIncludingAncestors", rv);
@@ -292,7 +292,7 @@ std::string TestFileRef::TestMakeDirectory() {
     return "FileSystem::MakeDirectoryIncludingAncestors "
            "ran callback synchronously.";
   }
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::MakeDirectoryIncludingAncestors not aborted.";
@@ -303,7 +303,7 @@ std::string TestFileRef::TestMakeDirectory() {
   // MakeDirectory with nested path.
   dir_ref = pp::FileRef_Dev(file_system, "/dir_make_dir_3/dir_make_dir_4");
   rv = dir_ref.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv == PP_OK) {
     return "Calling FileSystem::MakeDirectory() with a nested directory path "
@@ -317,7 +317,7 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -327,14 +327,14 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   rv = file_io.Open(file_ref,
                     PP_FILEOPENFLAG_CREATE | PP_FILEOPENFLAG_WRITE,
                     callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  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.
   rv = file_io.Write(0, "test", 4, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != 4)
     return ReportError("FileIO::Write", rv);
@@ -345,7 +345,7 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   const PP_Time last_access_time = 123 * 24 * 3600.0;
   const PP_Time last_modified_time = 246.0;
   rv = file_ref.Touch(last_access_time, last_modified_time, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Touch", rv);
@@ -356,7 +356,7 @@ std::string TestFileRef::TestQueryAndTouchFile() {
       .Touch(last_access_time, last_modified_time, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Touch ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Touch not aborted.";
@@ -367,7 +367,7 @@ std::string TestFileRef::TestQueryAndTouchFile() {
   // Query.
   PP_FileInfo_Dev info;
   rv = file_io.Query(&info, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Query", rv);
@@ -387,7 +387,7 @@ std::string TestFileRef::TestQueryAndTouchFile() {
       last_access_time, last_modified_time, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Touch ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Touch not aborted.";
@@ -402,7 +402,7 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -410,33 +410,33 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
   pp::FileRef_Dev file_ref(file_system, "/file_delete");
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
 
   rv = file_ref.Delete(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Delete", rv);
 
   pp::FileRef_Dev dir_ref(file_system, "/dir_delete");
   rv = dir_ref.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectory", rv);
 
   rv = dir_ref.Delete(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Delete", rv);
 
   pp::FileRef_Dev nested_dir_ref(file_system, "/dir_delete_1/dir_delete_2");
   rv = nested_dir_ref.MakeDirectoryIncludingAncestors(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectoryIncludingAncestors", rv);
@@ -444,14 +444,14 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
   // Hang on to a ref to the parent; otherwise the callback will be aborted.
   pp::FileRef_Dev parent_dir_ref = nested_dir_ref.GetParent();
   rv = parent_dir_ref.Delete(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FAILED)
     return ReportError("FileSystem::Delete", rv);
 
   pp::FileRef_Dev nonexistent_file_ref(file_system, "/nonexistent_file_delete");
   rv = nonexistent_file_ref.Delete(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FILENOTFOUND)
     return ReportError("FileSystem::Delete", rv);
@@ -461,7 +461,7 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_delete_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)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
@@ -471,7 +471,7 @@ std::string TestFileRef::TestDeleteFileAndDirectory() {
   }
   if (callback.run_count() > 0)
     return "FileSystem::Delete ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Delete not aborted.";
@@ -486,7 +486,7 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
   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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -494,42 +494,42 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
   pp::FileRef_Dev file_ref(file_system, "/file_rename");
   pp::FileIO_Dev file_io(instance_);
   rv = file_io.Open(file_ref, PP_FILEOPENFLAG_CREATE, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     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)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Rename", rv);
 
   pp::FileRef_Dev dir_ref(file_system, "/dir_rename");
   rv = dir_ref.MakeDirectory(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectory", rv);
 
   pp::FileRef_Dev target_dir_ref(file_system, "/target_dir_rename");
   rv = dir_ref.Rename(target_dir_ref, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Rename", rv);
 
   pp::FileRef_Dev nested_dir_ref(file_system, "/dir_rename_1/dir_rename_2");
   rv = nested_dir_ref.MakeDirectoryIncludingAncestors(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::MakeDirectoryIncludingAncestors", rv);
 
   pp::FileRef_Dev target_nested_dir_ref(file_system, "/dir_rename_1");
   rv = nested_dir_ref.Rename(target_nested_dir_ref, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_ERROR_FAILED)
     return ReportError("FileSystem::Rename", rv);
@@ -543,7 +543,7 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
     pp::FileRef_Dev file_ref_abort(file_system, "/file_rename_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)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv != PP_OK)
       return ReportError("FileIO::Open", rv);
@@ -553,7 +553,7 @@ std::string TestFileRef::TestRenameFileAndDirectory() {
   }
   if (callback.run_count() > 0)
     return "FileSystem::Rename ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Rename not aborted.";
diff --git a/ppapi/tests/test_file_system.cc b/ppapi/tests/test_file_system.cc
index 958f896..7758f5f 100644
--- a/ppapi/tests/test_file_system.cc
+++ b/ppapi/tests/test_file_system.cc
@@ -28,7 +28,7 @@ std::string TestFileSystem::TestOpen() {
   // Open.
   pp::FileSystem_Dev file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
   int32_t rv = file_system.Open(1024, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileSystem::Open", rv);
@@ -39,7 +39,7 @@ std::string TestFileSystem::TestOpen() {
       .Open(1024, callback);
   if (callback.run_count() > 0)
     return "FileSystem::Open ran callback synchronously.";
-  if (rv == PP_ERROR_WOULDBLOCK) {
+  if (rv == PP_OK_COMPLETIONPENDING) {
     rv = callback.WaitForResult();
     if (rv != PP_ERROR_ABORTED)
       return "FileSystem::Open not aborted.";
@@ -61,17 +61,17 @@ std::string TestFileSystem::TestMultipleOpens() {
 
   TestCompletionCallback callback_2(instance_->pp_instance());
   int32_t rv_2 = file_system.Open(1024, callback_2);
-  if (rv_2 == PP_ERROR_WOULDBLOCK || rv_2 == PP_OK)
+  if (rv_2 == PP_OK_COMPLETIONPENDING || rv_2 == PP_OK)
     return "FileSystem::Open should not allow multiple opens.";
 
-  if (rv_1 == PP_ERROR_WOULDBLOCK)
+  if (rv_1 == PP_OK_COMPLETIONPENDING)
     rv_1 = callback_1.WaitForResult();
   if (rv_1 != PP_OK)
     return ReportError("FileSystem::Open", rv_1);
 
   TestCompletionCallback callback_3(instance_->pp_instance());
   int32_t rv_3 = file_system.Open(1024, callback_3);
-  if (rv_3 == PP_ERROR_WOULDBLOCK || rv_3 == PP_OK)
+  if (rv_3 == PP_OK_COMPLETIONPENDING || rv_3 == PP_OK)
     return "FileSystem::Open should not allow multiple opens.";
 
   PASS();
diff --git a/ppapi/tests/test_graphics_2d.cc b/ppapi/tests/test_graphics_2d.cc
index f9bafc1..6c484b9 100644
--- a/ppapi/tests/test_graphics_2d.cc
+++ b/ppapi/tests/test_graphics_2d.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -92,7 +92,7 @@ bool TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
   int32_t rv = context->Flush(cc);
   if (rv == PP_OK)
     return true;
-  if (rv != PP_ERROR_WOULDBLOCK)
+  if (rv != PP_OK_COMPLETIONPENDING)
     return false;
   testing_interface_->RunMessageLoop(instance_->pp_instance());
   return true;
@@ -524,7 +524,7 @@ std::string TestGraphics2D::TestFlush() {
   dc.PaintImageData(background, pp::Point(0, 0));
 
   int32_t rv = dc.Flush(pp::CompletionCallback::Block());
-  if (rv == PP_OK || rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
     return "Flush succeeded from the main thread with no callback.";
 
   // Test flushing with no operations still issues a callback.
@@ -537,13 +537,13 @@ std::string TestGraphics2D::TestFlush() {
 
   // Test that multiple flushes fail if we don't get a callback in between.
   rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
-  if (rv != PP_OK && rv != PP_ERROR_WOULDBLOCK)
+  if (rv != PP_OK && rv != PP_OK_COMPLETIONPENDING)
     return "Couldn't flush first time for multiple flush test.";
 
   if (rv != PP_OK) {
     // If the first flush would block, then a second should fail.
     rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
-    if (rv == PP_OK || rv == PP_ERROR_WOULDBLOCK)
+    if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
       return "Second flush succeeded before callback ran.";
   }
 
diff --git a/ppapi/tests/test_transport.cc b/ppapi/tests/test_transport.cc
index 72ead1b..4035676 100644
--- a/ppapi/tests/test_transport.cc
+++ b/ppapi/tests/test_transport.cc
@@ -36,17 +36,17 @@ std::string TestTransport::TestBasics() {
 
   TestCompletionCallback connect_cb1(instance_->pp_instance());
   TestCompletionCallback connect_cb2(instance_->pp_instance());
-  ASSERT_EQ(transport1.Connect(connect_cb1), PP_ERROR_WOULDBLOCK);
-  ASSERT_EQ(transport2.Connect(connect_cb2), PP_ERROR_WOULDBLOCK);
+  ASSERT_EQ(transport1.Connect(connect_cb1), PP_OK_COMPLETIONPENDING);
+  ASSERT_EQ(transport2.Connect(connect_cb2), PP_OK_COMPLETIONPENDING);
 
   pp::Var address1;
   pp::Var address2;
   TestCompletionCallback next_address_cb1(instance_->pp_instance());
   TestCompletionCallback next_address_cb2(instance_->pp_instance());
   ASSERT_EQ(transport1.GetNextAddress(&address1, next_address_cb1),
-            PP_ERROR_WOULDBLOCK);
+            PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(transport2.GetNextAddress(&address2, next_address_cb2),
-            PP_ERROR_WOULDBLOCK);
+            PP_OK_COMPLETIONPENDING);
   ASSERT_EQ(next_address_cb1.WaitForResult(), 0);
   ASSERT_EQ(next_address_cb2.WaitForResult(), 0);
   ASSERT_EQ(transport1.GetNextAddress(&address1, next_address_cb1), PP_OK);
diff --git a/ppapi/tests/test_url_loader.cc b/ppapi/tests/test_url_loader.cc
index 2b606c2..1faacfc 100644
--- a/ppapi/tests/test_url_loader.cc
+++ b/ppapi/tests/test_url_loader.cc
@@ -62,7 +62,7 @@ std::string TestURLLoader::ReadEntireFile(pp::FileIO_Dev* file_io,
 
   for (;;) {
     int32_t rv = file_io->Read(offset, buf, sizeof(buf), callback);
-    if (rv == PP_ERROR_WOULDBLOCK)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return ReportError("FileIO::Read", rv);
@@ -82,7 +82,7 @@ std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
 
   for (;;) {
     int32_t rv = loader->ReadResponseBody(buf, sizeof(buf), callback);
-    if (rv == PP_ERROR_WOULDBLOCK)
+    if (rv == PP_OK_COMPLETIONPENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return ReportError("URLLoader::ReadResponseBody", rv);
@@ -101,7 +101,7 @@ std::string TestURLLoader::LoadAndCompareBody(
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
@@ -198,7 +198,7 @@ std::string TestURLLoader::TestStreamToFile() {
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
@@ -215,7 +215,7 @@ std::string TestURLLoader::TestStreamToFile() {
     return "URLResponseInfo::GetBody returned null";
 
   rv = loader.FinishStreamingToFile(callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::FinishStreamingToFile", rv);
@@ -223,7 +223,7 @@ std::string TestURLLoader::TestStreamToFile() {
 
   pp::FileIO_Dev reader;
   rv = reader.Open(body, PP_FILEOPENFLAG_READ, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("FileIO::Open", rv);
@@ -255,7 +255,7 @@ std::string TestURLLoader::TestSameOriginRestriction() {
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
 
   // We expect a failure.
@@ -282,7 +282,7 @@ std::string TestURLLoader::TestAuditURLRedirect() {
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
-  if (rv == PP_ERROR_WOULDBLOCK)
+  if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
@@ -314,7 +314,7 @@ std::string TestURLLoader::TestAbortCalls() {
     rv = pp::URLLoader(*instance_).Open(request, callback);
     if (callback.run_count() > 0)
       return "URLLoader::Open ran callback synchronously.";
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       rv = callback.WaitForResult();
       if (rv != PP_ERROR_ABORTED)
         return "URLLoader::Open not aborted.";
@@ -329,7 +329,7 @@ std::string TestURLLoader::TestAbortCalls() {
     {
       pp::URLLoader loader(*instance_);
       rv = loader.Open(request, callback);
-      if (rv == PP_ERROR_WOULDBLOCK)
+      if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("URLLoader::Open", rv);
@@ -337,7 +337,7 @@ std::string TestURLLoader::TestAbortCalls() {
       callback.reset_run_count();
       rv = loader.ReadResponseBody(buf, sizeof(buf), callback);
     }  // Destroy |loader|.
-    if (rv == PP_ERROR_WOULDBLOCK) {
+    if (rv == PP_OK_COMPLETIONPENDING) {
       // Save a copy and make sure |buf| doesn't get written to.
       char buf_copy[2];
       memcpy(&buf_copy, &buf, sizeof(buf));
diff --git a/ppapi/tests/test_utils.cc b/ppapi/tests/test_utils.cc
index fcaff40..622c758 100644
--- a/ppapi/tests/test_utils.cc
+++ b/ppapi/tests/test_utils.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -27,14 +27,14 @@ std::string ReportError(const char* method, int32_t error) {
 }
 
 TestCompletionCallback::TestCompletionCallback(PP_Instance instance)
-    : result_(PP_ERROR_WOULDBLOCK),
+    : result_(PP_OK_COMPLETIONPENDING),
       post_quit_task_(false),
       run_count_(0),
       instance_(instance) {
 }
 
 int32_t TestCompletionCallback::WaitForResult() {
-  result_ = PP_ERROR_WOULDBLOCK;  // Reset
+  result_ = PP_OK_COMPLETIONPENDING;  // Reset
   post_quit_task_ = true;
   GetTestingInterface()->RunMessageLoop(instance_);
   return result_;