PPAPI: Force async callback invocation option.

ppapi/tests/test_graphics_2d.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_graphics_2d.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
@@ skipping 25 matching lines @@
 bool TestGraphics2D::Init() {
   graphics_2d_interface_ = reinterpret_cast<PPB_Graphics2D const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_GRAPHICS_2D_INTERFACE));
   image_data_interface_ = reinterpret_cast<PPB_ImageData const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_IMAGEDATA_INTERFACE));
   return graphics_2d_interface_ && image_data_interface_ &&
          InitTestingInterface();
 }
 
 void TestGraphics2D::RunTest() {
-  instance_->LogTest("InvalidResource", TestInvalidResource());
-  instance_->LogTest("InvalidSize", TestInvalidSize());
-  instance_->LogTest("Humongous", TestHumongous());
-  instance_->LogTest("InitToZero", TestInitToZero());
-  instance_->LogTest("Describe", TestDescribe());
-  instance_->LogTest("Paint", TestPaint());
-  //instance_->LogTest("Scroll", TestScroll());  // TODO(brettw) implement.
-  instance_->LogTest("Replace", TestReplace());
-  instance_->LogTest("Flush", TestFlush());
+  RUN_TEST(InvalidResource);
+  RUN_TEST(InvalidSize);
+  RUN_TEST(Humongous);
+  RUN_TEST(InitToZero);
+  RUN_TEST(Describe);
+  RUN_ASYNC_TEST(Paint);
+  // RUN_ASYNC_TEST(Scroll);  // TODO(brettw) implement.
+  RUN_ASYNC_TEST(Replace);
+  RUN_ASYNC_TEST(Flush);
 }
 
 void TestGraphics2D::QuitMessageLoop() {
   testing_interface_->QuitMessageLoop(instance_->pp_instance());
 }
 
 bool TestGraphics2D::ReadImageData(const pp::Graphics2D& dc,
                                    pp::ImageData* image,
                                    const pp::Point& top_left) const {
   return pp::PPBoolToBool(testing_interface_->ReadImageData(
       dc.pp_resource(),
       image->pp_resource(),
       &top_left.pp_point()));
 }
 
 bool TestGraphics2D::IsDCUniformColor(const pp::Graphics2D& dc,
                                       uint32_t color) const {
   pp::ImageData readback(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                          dc.size(), false);
   if (readback.is_null())
     return false;
   if (!ReadImageData(dc, &readback, pp::Point(0, 0)))
     return false;
   return IsSquareInImage(readback, 0, pp::Rect(dc.size()), color);
 }
 
 bool TestGraphics2D::FlushAndWaitForDone(pp::Graphics2D* context) {
-  pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this);
+  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
+  pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this, flags);
   int32_t rv = context->Flush(cc);
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return false;
   if (rv == PP_OK)
     return true;
   if (rv != PP_OK_COMPLETIONPENDING)
     return false;
   testing_interface_->RunMessageLoop(instance_->pp_instance());
   return true;
 }
 
 void TestGraphics2D::FillRectInImage(pp::ImageData* image,
                                      const pp::Rect& rect,
@@ skipping 108 matching lines @@
 
   // ReplaceContents.
   graphics_2d_interface_->ReplaceContents(image.pp_resource(),
                                           image.pp_resource());
   graphics_2d_interface_->ReplaceContents(null_context.pp_resource(),
                                           image.pp_resource());
 
   // Flush.
   if (graphics_2d_interface_->Flush(
           image.pp_resource(),
-          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
+          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a different resource";
   if (graphics_2d_interface_->Flush(
           null_context.pp_resource(),
-          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
+          PP_MakeOptionalCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a NULL resource";
 
   // ReadImageData.
   if (testing_interface_->ReadImageData(image.pp_resource(),
                                         image.pp_resource(),
                                         &zero_zero))
     return "ReadImageData succeeded with a different resource";
   if (testing_interface_->ReadImageData(null_context.pp_resource(),
                                         image.pp_resource(),
                                         &zero_zero))
@@ skipping 292 matching lines @@
     return "Flush succeeded from the main thread with no callback.";
 
   // Test flushing with no operations still issues a callback.
   // (This may also hang if the browser never issues the callback).
   pp::Graphics2D dc_nopaints(instance_, pp::Size(w, h), false);
   if (dc.is_null())
     return "Failure creating the nopaint device";
   if (!FlushAndWaitForDone(&dc_nopaints))
     return "Couldn't flush the nopaint device";
 
+  int32_t flags = (force_async_ ? 0 : PP_COMPLETIONCALLBACK_FLAG_OPTIONAL);
+
   // Test that multiple flushes fail if we don't get a callback in between.
-  rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
+  rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL,
+                                                flags));
+  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
+    return "Flush must complete asynchronously.";
   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_OK_COMPLETIONPENDING)
-      return "Second flush succeeded before callback ran.";
+  if (rv == PP_OK_COMPLETIONPENDING) {
+    // If the first flush completes asynchronously, then a second should fail.
+    rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL,
+                                                  flags));
+    if (force_async_) {
+      if (rv != PP_OK_COMPLETIONPENDING)
+        return "Second flush must fail asynchronously.";
+    } else {
+      if (rv == PP_OK || rv == PP_OK_COMPLETIONPENDING)
+        return "Second flush succeeded before callback ran.";
+    }
   }
 
   PASS();
 }