Switch FlushCallback to be a PP_CompletionCallback....

tests/test_device_context_2d.cc

 // Copyright (c) 2010 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_device_context_2d.h"
 
 #include <string.h>
 
+#include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_testing.h"
+#include "ppapi/c/ppb_device_context_2d.h"
+#include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/device_context_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/tests/test_instance.h"
 
 namespace {
 
 // A NOP flush callback for use in various tests.
-void FlushCallbackNOP(PP_Resource context, void* data) {
+void FlushCallbackNOP(void* data, int32_t result) {
 }
 
-void FlushCallbackQuitMessageLoop(PP_Resource context, void* data) {
+void FlushCallbackQuitMessageLoop(void* data, int32_t result) {
   reinterpret_cast<TestDeviceContext2D*>(data)->QuitMessageLoop();
 }
 
 }  // namespace
 
 bool TestDeviceContext2D::Init() {
   device_context_interface_ = reinterpret_cast<PPB_DeviceContext2D const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_DEVICECONTEXT2D_INTERFACE));
   image_data_interface_ = reinterpret_cast<PPB_ImageData const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_IMAGEDATA_INTERFACE));
@@ skipping 44 matching lines @@
   if (readback.is_null())
     return false;
   if (!ReadImageData(dc, &readback, 0, 0))
     return false;
   return IsSquareInImage(readback, 0,
                          PP_MakeRectFromXYWH(0, 0, dc.width(), dc.height()),
                          color);
 }
 
 bool TestDeviceContext2D::FlushAndWaitForDone(pp::DeviceContext2D* context) {
-  if (!context->Flush(&FlushCallbackQuitMessageLoop, this))
+  pp::CompletionCallback cc(&FlushCallbackQuitMessageLoop, this);
+  int32_t rv = context->Flush(cc);
+  if (rv == PP_OK)
+    return true;
+  if (rv != PP_Error_WouldBlock)
     return false;
   testing_interface_->RunMessageLoop();
   return true;
 }
 
 void TestDeviceContext2D::FillRectInImage(pp::ImageData* image,
                                           const PP_Rect& rect,
                                           uint32_t color) const {
   for (int y = rect.point.y; y < rect.point.y + rect.size.height; y++) {
     uint32_t* row = image->GetAddr32(rect.point.x, y);
@@ skipping 69 matching lines @@
 
   // ReplaceContents.
   if (device_context_interface_->ReplaceContents(image.pp_resource(),
                                                  image.pp_resource()))
     return "ReplaceContents succeeded with a different resource";
   if (device_context_interface_->ReplaceContents(null_context.pp_resource(),
                                                  image.pp_resource()))
     return "ReplaceContents succeeded with a NULL resource";
 
   // Flush.
-  if (device_context_interface_->Flush(image.pp_resource(),
-                                       &FlushCallbackNOP, NULL))
+  if (device_context_interface_->Flush(
+          image.pp_resource(),
+          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a different resource";
-  if (device_context_interface_->Flush(null_context.pp_resource(),
-                                       &FlushCallbackNOP, NULL))
+  if (device_context_interface_->Flush(
+          null_context.pp_resource(),
+          PP_MakeCompletionCallback(&FlushCallbackNOP, NULL)) == PP_OK)
     return "Flush succeeded with a NULL resource";
 
   // ReadImageData.
   if (testing_interface_->ReadImageData(image.pp_resource(),
                                                image.pp_resource(), 0, 0))
     return "ReadImageData succeeded with a different resource";
   if (testing_interface_->ReadImageData(null_context.pp_resource(),
                                                image.pp_resource(), 0, 0))
     return "ReadImageData succeeded with a NULL resource";
 
@@ skipping 228 matching lines @@
   if (dc.is_null())
     return "Failure creating a boring device";
 
   // Fill the background with blue but don't flush yet.
   pp::ImageData background(PP_IMAGEDATAFORMAT_BGRA_PREMUL, w, h, true);
   if (background.is_null())
     return "Failure to allocate background image";
   if (!dc.PaintImageData(background, 0, 0, NULL))
     return "Couldn't paint the background.";
 
-  if (dc.Flush(NULL, NULL))
+  int32_t rv = dc.Flush(pp::CompletionCallback::Block());
+  if (rv == PP_OK || rv == PP_Error_WouldBlock)
     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::DeviceContext2D dc_nopaints(w, h, false);
   if (dc.is_null())
     return "Failure creating the nopaint device";
   if (!FlushAndWaitForDone(&dc_nopaints))
     return "Couldn't flush the nopaint device";
 
   // Test that multiple flushes fail if we don't get a callback in between.
-  if (!dc_nopaints.Flush(&FlushCallbackNOP, NULL))
+  rv = dc_nopaints.Flush(pp::CompletionCallback(&FlushCallbackNOP, NULL));
+  if (rv != PP_OK && rv != PP_Error_WouldBlock)
     return "Couldn't flush first time for multiple flush test.";
-  if (dc_nopaints.Flush(&FlushCallbackNOP, NULL))
-    return "Second flush succeeded before callback ran.";
+
+  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)
+      return "Second flush succeeded before callback ran.";
+  }
 
   return "";
 }