Implement an input event resource.

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/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/proxy/host_dispatcher.h"
@@ skipping 93 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
                         OnMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
                         OnMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
                         OnMsgExecuteScript)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
                         OnMsgSetFullscreen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
                         OnMsgGetScreenSize)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
+                        OnMsgRequestInputEvents)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
+                        OnMsgClearInputEvents)
     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 62 matching lines @@
 }
 
 PP_Bool PPB_Instance_Proxy::GetScreenSize(PP_Instance instance,
                                           PP_Size* size) {
   PP_Bool result = PP_FALSE;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetScreenSize(
       INTERFACE_ID_PPB_INSTANCE, instance, &result, size));
   return result;
 }
 
+int32_t PPB_Instance_Proxy::RequestInputEvents(PP_Instance instance,
+                                               uint32_t event_classes) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_RequestInputEvents(
+      INTERFACE_ID_PPB_INSTANCE, instance, false, event_classes));
+
+  // We always register for the classes we can handle, this function validates
+  // the flags so we can notify it if anything was invalid, withougt requiring

[dmichael (off chromium), 2011/07/01 20:04:19]

withougt->without

+  // a sync reply.
+  return ValidateRequestInputEvents(false, event_classes);
+}
+
+int32_t PPB_Instance_Proxy::RequestFilteringInputEvents(
+    PP_Instance instance,
+    uint32_t event_classes) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_RequestInputEvents(
+      INTERFACE_ID_PPB_INSTANCE, instance, true, event_classes));
+
+  // We always register for the classes we can handle, this function validates
+  // the flags so we can notify it if anything was invalid, withougt requiring

[dmichael (off chromium), 2011/07/01 20:04:19]

withougt->without

+  // a sync reply.
+  return ValidateRequestInputEvents(true, event_classes);
+}
+
+void PPB_Instance_Proxy::ClearInputEventRequest(PP_Instance instance,
+                                                uint32_t event_classes) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_ClearInputEvents(
+      INTERFACE_ID_PPB_INSTANCE, instance, event_classes));

[dmichael (off chromium), 2011/07/01 20:04:19]

Because this message is asynchronous & the proxy doesn't do any filtering
(unless I missed it), this has the side effect that an o.o.p. plugin might get
input events after clearing them.

Kind of a minor point, but if you don't fix it in this CL (with maybe some
proxy, plugin-side filtering? Or the easier way of just making it sync?), it
would be good to file a bug.

[brettw, 2011/07/01 21:14:52]

Making this message sync doesn't help because there could already be a bunch of
messages "in flight" at the time of the call that are queued up. I will mention
that this can happen.

+}
+
 void PPB_Instance_Proxy::OnMsgGetWindowObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 }
 
 void PPB_Instance_Proxy::OnMsgGetOwnerElementObject(
     PP_Instance instance,
@@ skipping 51 matching lines @@
 }
 
 void PPB_Instance_Proxy::OnMsgGetScreenSize(PP_Instance instance,
                                             PP_Bool* result,
                                             PP_Size* size) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->GetScreenSize(instance, size);
 }
 
+void PPB_Instance_Proxy::OnMsgRequestInputEvents(PP_Instance instance,
+                                                 bool is_filtering,
+                                                 uint32_t event_classes) {
+  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  if (enter.succeeded()) {
+    if (is_filtering)
+      enter.functions()->RequestFilteringInputEvents(instance, event_classes);
+    else
+      enter.functions()->RequestInputEvents(instance, event_classes);
+  }
+}
+
+void PPB_Instance_Proxy::OnMsgClearInputEvents(PP_Instance instance,
+                                               uint32_t event_classes) {
+  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
+  if (enter.succeeded())
+    enter.functions()->ClearInputEventRequest(instance, event_classes);
+}
+
 }  // namespace proxy
 }  // namespace pp