PPAPI: Make blocking completion callbacks work.

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 89 matching lines @@
 #endif
 
 using base::StringPrintf;
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
 using ppapi::PPB_InputEvent_Shared;
 using ppapi::PPB_View_Shared;
 using ppapi::PPP_Instance_Combined;
 using ppapi::ScopedPPResource;
 using ppapi::StringVar;
+using ppapi::TrackedCallback;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::Var;
 using ppapi::ViewData;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebCursorInfo;
@@ skipping 223 matching lines @@
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       selection_caret_(0),
       selection_anchor_(0),
-      lock_mouse_callback_(PP_BlockUntilComplete()),
       pending_user_gesture_(0.0),
       flash_impl_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 
   view_data_.is_page_visible = delegate->IsPageVisible();
 }
 
 PluginInstance::~PluginInstance() {
   DCHECK(!fullscreen_container_);
 
   // Free all the plugin objects. This will automatically clear the back-
   // pointer from the NPObject so WebKit can't call into the plugin any more.
   //
   // Swap out the set so we can delete from it (the objects will try to
   // unregister themselves inside the delete call).
   PluginObjectSet plugin_object_copy;
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
        i != plugin_object_copy.end(); ++i)
     delete *i;
 
-  if (lock_mouse_callback_.func)
-    PP_RunAndClearCompletionCallback(&lock_mouse_callback_, PP_ERROR_ABORTED);
+  if (lock_mouse_callback_)
+    TrackedCallback::ClearAndAbort(&lock_mouse_callback_);
 
   delegate_->InstanceDeleted(this);
   module_->InstanceDeleted(this);
 
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
@@ skipping 1195 matching lines @@
 bool PluginInstance::IsProcessingUserGesture() {
   PP_TimeTicks now =
       ::ppapi::TimeTicksToPPTimeTicks(base::TimeTicks::Now());
   // Give a lot of slack so tests won't be flaky. Well behaved plugins will
   // close the user gesture.
   const PP_TimeTicks kUserGestureDurationInSeconds = 10.0;
   return (now - pending_user_gesture_ < kUserGestureDurationInSeconds);
 }
 
 void PluginInstance::OnLockMouseACK(bool succeeded) {
-  if (!lock_mouse_callback_.func) {
+  if (TrackedCallback::IsPending(lock_mouse_callback_)) {
     NOTREACHED();
     return;
   }
-  PP_RunAndClearCompletionCallback(&lock_mouse_callback_,
-                                   succeeded ? PP_OK : PP_ERROR_FAILED);
+  TrackedCallback::ClearAndRun(&lock_mouse_callback_,
+                               succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
 void PluginInstance::OnMouseLockLost() {
   if (LoadMouseLockInterface())
     plugin_mouse_lock_interface_->MouseLockLost(pp_instance());
 }
 
 void PluginInstance::HandleMouseLockedInputEvent(
     const WebKit::WebMouseEvent& event) {
   // |cursor_info| is ignored since it is hidden when the mouse is locked.
@@ skipping 333 matching lines @@
   if (!bitmap->copyTo(&custom_cursor->customImage.getSkBitmap(),
                       bitmap->config())) {
     return PP_FALSE;
   }
 
   DoSetCursor(custom_cursor.release());
   return PP_TRUE;
 }
 
 int32_t PluginInstance::LockMouse(PP_Instance instance,
-                                  PP_CompletionCallback callback) {
-  if (!callback.func) {
-    // Don't support synchronous call.
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-  }
-  if (lock_mouse_callback_.func)  // A lock is pending.
+                                  scoped_refptr<TrackedCallback> callback) {
+  if (TrackedCallback::IsPending(lock_mouse_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (delegate()->IsMouseLocked(this))
     return PP_OK;
 
   if (!CanAccessMainFrame())
     return PP_ERROR_NOACCESS;
 
   if (delegate()->LockMouse(this)) {
     lock_mouse_callback_ = callback;
@@ skipping 228 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit