Revert 93223 - Reland http://codereview.chromium.org/7452002/

ppapi/proxy/ppp_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/ppp_instance_proxy.h"
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
@@ skipping 47 matching lines @@
                                              instance, *position, *clip,
                                              fullscreen));
 }
 
 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   HostDispatcher::GetForInstance(instance)->Send(
       new PpapiMsg_PPPInstance_DidChangeFocus(INTERFACE_ID_PPP_INSTANCE,
                                               instance, has_focus));
 }
 
+PP_Bool HandleInputEvent(PP_Instance instance,
+                         const PP_InputEvent* event) {
+  PP_Bool result = PP_FALSE;
+  IPC::Message* msg = new PpapiMsg_PPPInstance_HandleInputEvent(
+      INTERFACE_ID_PPP_INSTANCE, instance, *event, &result);
+  // Make this message not unblock, to avoid re-entrancy problems when the
+  // plugin does a synchronous call to the renderer. This will force any
+  // synchronous calls from the plugin to complete before processing this
+  // message. We avoid deadlock by never un-setting the unblock flag on messages
+  // from the plugin to the renderer.
+  msg->set_unblock(false);
+  HostDispatcher::GetForInstance(instance)->Send(msg);
+  return result;
+}
+
 PP_Bool HandleDocumentLoad(PP_Instance instance,
                            PP_Resource url_loader) {
   PP_Bool result = PP_FALSE;
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
 
   // Set up the URLLoader for proxying.
 
   PPB_URLLoader_Proxy* url_loader_proxy = static_cast<PPB_URLLoader_Proxy*>(
       dispatcher->GetOrCreatePPBInterfaceProxy(INTERFACE_ID_PPB_URL_LOADER));
   url_loader_proxy->PrepareURLLoaderForSendingToPlugin(url_loader);
@@ skipping 12 matching lines @@
   }
   core->AddRefResource(url_loader);
 
   HostResource serialized_loader;
   serialized_loader.SetHostResource(instance, url_loader);
   dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
       INTERFACE_ID_PPP_INSTANCE, instance, serialized_loader, &result));
   return result;
 }
 
-static const PPP_Instance_1_0 instance_interface_1_0 = {
+static const PPP_Instance_0_5 instance_interface_0_5 = {
   &DidCreate,
   &DidDestroy,
   &DidChangeView,
   &DidChangeFocus,
+  &HandleInputEvent,
   &HandleDocumentLoad
 };
 
 template <class PPP_Instance_Type>
 InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher,
                                     const void* target_interface) {
   return new PPP_Instance_Proxy(
       dispatcher,
       static_cast<const PPP_Instance_Type*>(target_interface));
 }
 
 }  // namespace
 
 PPP_Instance_Proxy::~PPP_Instance_Proxy() {
 }
 
 // static
-const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo1_0() {
+const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo0_5() {
   static const Info info = {
-    &instance_interface_1_0,
-    PPP_INSTANCE_INTERFACE_1_0,
+    &instance_interface_0_5,
+    PPP_INSTANCE_INTERFACE_0_5,
     INTERFACE_ID_PPP_INSTANCE,
     false,
-    &CreateInstanceProxy<PPP_Instance_1_0>,
+    &CreateInstanceProxy<PPP_Instance_0_5>,
   };
   return &info;
 }
 
 bool PPP_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPP_Instance_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidCreate,
                         OnMsgDidCreate)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidDestroy,
                         OnMsgDidDestroy)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidChangeView,
                         OnMsgDidChangeView)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidChangeFocus,
                         OnMsgDidChangeFocus)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_HandleInputEvent,
+                        OnMsgHandleInputEvent)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_HandleDocumentLoad,
                         OnMsgHandleDocumentLoad)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PPP_Instance_Proxy::OnMsgDidCreate(
     PP_Instance instance,
     const std::vector<std::string>& argn,
@@ skipping 45 matching lines @@
   data->position = position;
   data->fullscreen = fullscreen;
   combined_interface_->DidChangeView(instance, &position, &clip);
 }
 
 void PPP_Instance_Proxy::OnMsgDidChangeFocus(PP_Instance instance,
                                              PP_Bool has_focus) {
   combined_interface_->DidChangeFocus(instance, has_focus);
 }
 
+void PPP_Instance_Proxy::OnMsgHandleInputEvent(PP_Instance instance,
+                                               const PP_InputEvent& event,
+                                               PP_Bool* result) {
+  *result = combined_interface_->HandleInputEvent(instance, &event);
+}
+
 void PPP_Instance_Proxy::OnMsgHandleDocumentLoad(PP_Instance instance,
                                                  const HostResource& url_loader,
                                                  PP_Bool* result) {
   PP_Resource plugin_loader =
       PPB_URLLoader_Proxy::TrackPluginResource(url_loader);
   *result = combined_interface_->HandleDocumentLoad(instance, plugin_loader);
 
   // This balances the one reference that TrackPluginResource() initialized it
   // with. The plugin will normally take an additional reference which will keep
   // the resource alive in the plugin (and the one reference in the renderer
   // representing all plugin references).
   // Once all references at the plugin side are released, the renderer side will
   // be notified and release the reference added in HandleDocumentLoad() above.
   PluginResourceTracker::GetInstance()->ReleaseResource(plugin_loader);
 }
 
 }  // namespace proxy
 }  // namespace pp