PPAPI: Force async callback invocation option.

ppapi/proxy/ppb_surface_3d_proxy.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/proxy/ppb_surface_3d_proxy.h"
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/dev/ppb_surface_3d_dev.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_context_3d_proxy.h"
+#include "ppapi/thunk/common.h"
 
 namespace pp {
 namespace proxy {
 
 Surface3D::~Surface3D() {
   if (context_)
     context_->BindSurfaces(NULL, NULL);
 }
 
 namespace {
@@ skipping 44 matching lines @@
                   int32_t attribute,
                   int32_t* value) {
   // TODO(alokp): Implement me.
   return 0;
 }
 
 int32_t SwapBuffers(PP_Resource surface_id,
                     PP_CompletionCallback callback) {
   Surface3D* object = PluginResource::GetAs<Surface3D>(surface_id);
   if (!object)
-    return PP_ERROR_BADRESOURCE;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADRESOURCE);
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
       object->instance());
   if (!dispatcher)
-    return PP_ERROR_FAILED;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_FAILED);
 
   // For now, disallow blocking calls. We'll need to add support for other
   // threads to this later.
   if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_BADARGUMENT);
 
-  if (object->is_flush_pending())
-    return PP_ERROR_INPROGRESS;  // Can't have >1 flush pending.
+  if (object->is_flush_pending()) {
+    // Can't have >1 flush pending.
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_INPROGRESS);
+  }
 
   if (!object->context())
-    return PP_ERROR_FAILED;
+    return ppapi::thunk::MayForceCallback(callback, PP_ERROR_FAILED);
 
   object->set_current_flush_callback(callback);
 
   IPC::Message* msg = new PpapiHostMsg_PPBSurface3D_SwapBuffers(
       INTERFACE_ID_PPB_SURFACE_3D, object->host_resource());
   msg->set_unblock(true);
   dispatcher->Send(msg);
 
   object->context()->gles2_impl()->SwapBuffers();
 
@@ skipping 57 matching lines @@
                                       std::vector<int32_t> attribs,
                                       HostResource* result) {
   DCHECK(attribs.size() % 2 == 1);
   DCHECK(attribs.back() == PP_GRAPHICS3DATTRIB_NONE);
   PP_Resource resource =
       ppb_surface_3d_target()->Create(instance, config, &attribs.front());
   result->SetHostResource(instance, resource);
 }
 
 void PPB_Surface3D_Proxy::OnMsgSwapBuffers(const HostResource& surface_3d) {
-  CompletionCallback callback = callback_factory_.NewCallback(
+  CompletionCallback callback = callback_factory_.NewOptionalCallback(
       &PPB_Surface3D_Proxy::SendSwapBuffersACKToPlugin, surface_3d);
   int32_t result = ppb_surface_3d_target()->SwapBuffers(
       surface_3d.host_resource(), callback.pp_completion_callback());
   if (result != PP_OK_COMPLETIONPENDING) {
     // There was some error, so we won't get a flush callback. We need to now
     // issue the ACK to the plugin hears about the error. This will also clean
     // up the data associated with the callback.
     callback.Run(result);
   }
 }
@@ skipping 21 matching lines @@
 
 void PPB_Surface3D_Proxy::SendSwapBuffersACKToPlugin(
     int32_t result,
     const HostResource& surface_3d) {
   dispatcher()->Send(new PpapiMsg_PPBSurface3D_SwapBuffersACK(
       INTERFACE_ID_PPB_SURFACE_3D, surface_3d, result));
 }
 
 }  // namespace proxy
 }  // namespace pp