PPAPI: Make blocking completion callbacks work.

ppapi/tests/test_utils.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_utils.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #if defined(_MSC_VER)
 #include <windows.h>
@@ skipping 79 matching lines @@
 }
 
 TestCompletionCallback::TestCompletionCallback(PP_Instance instance)
     : wait_for_result_called_(false),
       have_result_(false),
       result_(PP_OK_COMPLETIONPENDING),
       // TODO(dmichael): The default should probably be PP_REQUIRED, but this is
       //                 what the tests currently expect.
       callback_type_(PP_OPTIONAL),
       post_quit_task_(false),
+      run_count_(0),  // TODO(dmichael): Remove when all tests are updated.
       instance_(instance) {
 }
 
 TestCompletionCallback::TestCompletionCallback(PP_Instance instance,
                                                bool force_async)
     : wait_for_result_called_(false),
       have_result_(false),
       result_(PP_OK_COMPLETIONPENDING),
       callback_type_(force_async ? PP_REQUIRED : PP_OPTIONAL),
       post_quit_task_(false),
@@ skipping 55 matching lines @@
   WaitForResult(result);
   int32_t final_result = result_;
   if (result == PP_OK_COMPLETIONPENDING) {
     if (final_result != PP_ERROR_ABORTED) {
       errors_.assign(
           ReportError("TestCompletionCallback: Expected PP_ERROR_ABORTED or "
                       "PP_OK. Ran asynchronously.",
                       final_result));
       return;
     }
-  } else if (result != PP_OK) {
+  } else if (result < PP_OK) {
     errors_.assign(
-        ReportError("TestCompletionCallback: Expected PP_ERROR_ABORTED or"
-                    "PP_OK. Ran synchronously.",
+        ReportError("TestCompletionCallback: Expected PP_ERROR_ABORTED or "
+                    "non-error response. Ran synchronously.",
                     result));
     return;
   }
 }
 
 pp::CompletionCallback TestCompletionCallback::GetCallback() {
   Reset();
   int32_t flags = 0;
   if (callback_type_ == PP_BLOCKING)
     return pp::CompletionCallback();
   else if (callback_type_ == PP_OPTIONAL)
     flags = PP_COMPLETIONCALLBACK_FLAG_OPTIONAL;
   return pp::CompletionCallback(&TestCompletionCallback::Handler,
                                 const_cast<TestCompletionCallback*>(this),
                                 flags);
 }
 
 void TestCompletionCallback::Reset() {
   wait_for_result_called_ = false;
   result_ = PP_OK_COMPLETIONPENDING;
   have_result_ = false;
   post_quit_task_ = false;
+  run_count_ = 0;  // TODO(dmichael): Remove when all tests are updated.
   errors_.clear();
 }
 
 // static
 void TestCompletionCallback::Handler(void* user_data, int32_t result) {
   TestCompletionCallback* callback =
       static_cast<TestCompletionCallback*>(user_data);
+  // If this check fails, it means that the callback was invoked twice or that
+  // the PPAPI call completed synchronously, but also ran the callback.
   PP_DCHECK(!callback->have_result_);
   callback->result_ = result;
   callback->have_result_ = true;
+  callback->run_count_++;  // TODO(dmichael): Remove when all tests are updated.
   if (callback->post_quit_task_) {
     callback->post_quit_task_ = false;
     GetTestingInterface()->QuitMessageLoop(callback->instance_);
   }
 }