Remove the proxy callback tracker.

ppapi/proxy/ppb_instance_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_instance_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppb_mouse_lock.h"
+#include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/url_util_impl.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 
 // Windows headers interfere with this file.
@@ skipping 12 matching lines @@
 
 typedef EnterFunctionNoLock<PPB_Instance_FunctionAPI> EnterInstanceNoLock;
 
 InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher) {
   return new PPB_Instance_Proxy(dispatcher);
 }
 
 }  // namespace
 
 PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher)
-    : InterfaceProxy(dispatcher) {
+    : InterfaceProxy(dispatcher),
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Instance_Proxy::~PPB_Instance_Proxy() {
 }
 
 // static
 const InterfaceProxy::Info* PPB_Instance_Proxy::GetInfoPrivate() {
   static const Info info = {
     ppapi::thunk::GetPPB_Instance_Private_Thunk(),
     PPB_INSTANCE_PRIVATE_INTERFACE,
     INTERFACE_ID_NONE,  // 1_0 is the canonical one.
     false,
     &CreateInstanceProxy,
   };
   return &info;
 }
 
 bool PPB_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // Prevent the dispatcher from going away during a call to ExecuteScript.
   // This must happen OUTSIDE of ExecuteScript since the SerializedVars use
   // the dispatcher upon return of the function (converting the
   // SerializedVarReturnValue/OutParam to a SerializedVar in the destructor).
   ScopedModuleReference death_grip(dispatcher());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Instance_Proxy, msg)
+    // Plugin -> Host messages.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
                         OnMsgGetWindowObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
                         OnMsgGetOwnerElementObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
                         OnMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
                         OnMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
                         OnMsgExecuteScript)
@@ skipping 24 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
                         OnMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
                         OnMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
                         OnMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
                         OnMsgGetDocumentURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
                         OnMsgGetPluginInstanceURL)
+
+    // Host -> Plugin messages.
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
+                        OnMsgMouseLockComplete)
+
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 PPB_Instance_FunctionAPI* PPB_Instance_Proxy::AsPPB_Instance_FunctionAPI() {
   return this;
 }
 
 PP_Bool PPB_Instance_Proxy::BindGraphics(PP_Instance instance,
@@ skipping 234 matching lines @@
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
       INTERFACE_ID_PPB_INSTANCE,
       instance, SerializedVarSendInput(dispatcher(), message)));
 }
 
 int32_t PPB_Instance_Proxy::LockMouse(PP_Instance instance,
                                       PP_CompletionCallback callback) {
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
 
+  // Save the mouse callback on the instance data.
+  InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
+      GetInstanceData(instance);
+  if (!data)
+    return PP_ERROR_BADARGUMENT;
+  if (data->mouse_lock_callback.func)
+    return PP_ERROR_INPROGRESS;  // Already have a pending callback.
+  data->mouse_lock_callback = callback;
+
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_LockMouse(
-      INTERFACE_ID_PPB_INSTANCE, instance, SendCallback(callback)));
+      INTERFACE_ID_PPB_INSTANCE, instance));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_Instance_Proxy::UnlockMouse(PP_Instance instance) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UnlockMouse(
       INTERFACE_ID_PPB_INSTANCE, instance));
 }
 
 void PPB_Instance_Proxy::OnMsgGetWindowObject(
     PP_Instance instance,
@@ skipping 130 matching lines @@
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
 void PPB_Instance_Proxy::OnMsgPostMessage(PP_Instance instance,
                                           SerializedVarReceiveInput message) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->PostMessage(instance, message.Get(dispatcher()));
 }
 
-void PPB_Instance_Proxy::OnMsgLockMouse(PP_Instance instance,
-                                        uint32_t serialized_callback) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
-  if (enter.failed())
-    return;
-  PP_CompletionCallback callback = ReceiveCallback(serialized_callback);
-  int32_t result = enter.functions()->LockMouse(instance, callback);
-  if (result != PP_OK_COMPLETIONPENDING)
-    PP_RunCompletionCallback(&callback, result);
+void PPB_Instance_Proxy::OnMsgLockMouse(PP_Instance instance) {
+  EnterHostFunctionForceCallback<PPB_Instance_FunctionAPI> enter(
+      instance, callback_factory_,
+      &PPB_Instance_Proxy::MouseLockCompleteInHost, instance);
+  if (enter.succeeded())
+    enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
 }
 
 void PPB_Instance_Proxy::OnMsgUnlockMouse(PP_Instance instance) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded())
     enter.functions()->UnlockMouse(instance);
 }
 
 void PPB_Instance_Proxy::OnMsgResolveRelativeToDocument(
     PP_Instance instance,
@@ skipping 37 matching lines @@
 void PPB_Instance_Proxy::OnMsgGetPluginInstanceURL(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetPluginInstanceURL(instance, NULL));
   }
 }
 
+void PPB_Instance_Proxy::OnMsgMouseLockComplete(PP_Instance instance,
+                                                int32_t result) {
+  // Save the mouse callback on the instance data.
+  InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
+      GetInstanceData(instance);
+  if (!data)
+    return;  // Instance was probably deleted.
+  if (!data->mouse_lock_callback.func) {
+    NOTREACHED();
+    return;
+  }
+  PP_RunAndClearCompletionCallback(&data->mouse_lock_callback, result);
+}
+
+void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
+                                                 PP_Instance instance) {
+  dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
+      INTERFACE_ID_PPB_INSTANCE, instance, result));
+}
+
 }  // namespace proxy
 }  // namespace ppapi