Proxy PPB_Input_Event, PPP_Input_Event, and associated IFs.

src/shared/ppapi_proxy/browser_ppp_input_event.cc

+// Copyright (c) 2011 The Native Client 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 "native_client/src/shared/ppapi_proxy/browser_ppp_input_event.h"
+
+#include "native_client/src/include/nacl_scoped_ptr.h"
+#include "native_client/src/include/portability.h"
+#include "native_client/src/shared/ppapi_proxy/browser_globals.h"
+#include "native_client/src/shared/ppapi_proxy/input_event_data.h"
+#include "native_client/src/shared/ppapi_proxy/object_serialize.h"
+#include "native_client/src/shared/ppapi_proxy/browser_ppp.h"
+#include "native_client/src/shared/ppapi_proxy/trusted/srpcgen/ppp_rpc.h"
+#include "native_client/src/shared/ppapi_proxy/utility.h"
+#include "native_client/src/third_party/ppapi/c/pp_resource.h"
+#include "native_client/src/third_party/ppapi/c/ppp_input_event.h"
+
+namespace ppapi_proxy {
+
+namespace {
+
+PP_Bool HandleInputEvent(PP_Instance instance, PP_Resource input_event) {
+  DebugPrintf("PPP_InputEvent::HandleInputEvent: instance=%"NACL_PRIu32", "
+              "input_event = %"NACL_PRIu32"\n",
+              instance, input_event);
+
+  PP_Var character_text = PP_MakeUndefined();
+  InputEventData data;
+  data.event_type = PPBInputEventInterface()->GetType(input_event);
+  data.event_time_stamp = PPBInputEventInterface()->GetTimeStamp(input_event);
+  data.event_modifiers = PPBInputEventInterface()->GetModifiers(input_event);
+  // The browser should not send us input events for which we have not
+  // registered.
+  DCHECK(BrowserInputEvent::InputEventTypeIsRegistered(instance,
+                                                       data.event_type));
+  // If the input event is not being filtered, we should ignore what the NaCl
+  // returns. This is consistent with what the browser does.
+  bool ignore_return_value =
+      !(BrowserInputEvent::InputEventTypeIsFiltered(instance, data.event_type));
+
+  switch (data.event_type) {
+    // These events all use the PPB_MouseInputEvent interface.
+    case PP_INPUTEVENT_TYPE_MOUSEDOWN:
+    case PP_INPUTEVENT_TYPE_MOUSEUP:
+    case PP_INPUTEVENT_TYPE_MOUSEENTER:
+    case PP_INPUTEVENT_TYPE_MOUSELEAVE:
+    case PP_INPUTEVENT_TYPE_MOUSEMOVE:
+    case PP_INPUTEVENT_TYPE_CONTEXTMENU:
+      data.mouse_button =
+          PPBMouseInputEventInterface()->GetMouseButton(input_event);
+      data.mouse_position =
+          PPBMouseInputEventInterface()->GetMousePosition(input_event);
+      data.mouse_click_count =
+          PPBMouseInputEventInterface()->GetMouseClickCount(input_event);
+      break;
+    // This event uses the PPB_WheelInputEvent interface.
+    case PP_INPUTEVENT_TYPE_MOUSEWHEEL:
+      data.wheel_delta =
+          PPBWheelInputEventInterface()->GetWheelDelta(input_event);
+      data.wheel_ticks =
+          PPBWheelInputEventInterface()->GetWheelTicks(input_event);
+      data.wheel_scroll_by_page =
+          PPBWheelInputEventInterface()->GetScrollByPage(input_event);
+      break;
+    // These events all use the PPB_KeyInputEvent interface.
+    case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYUP:
+    case PP_INPUTEVENT_TYPE_CHAR:
+      data.key_code =
+          PPBKeyboardInputEventInterface()->GetKeyCode(input_event);
+      character_text =
+          PPBKeyboardInputEventInterface()->GetCharacterText(input_event);
+      break;
+    case PP_INPUTEVENT_TYPE_UNDEFINED:
+      return PP_FALSE;
+    // No default case; if any new types are added we should get a compile
+    // warning.
+  }
+  // Now data and character_text have all the data we want to send to the
+  // untrusted side.
+
+  // character_text should either be undefined or a string type.
+  DCHECK((character_text.type == PP_VARTYPE_UNDEFINED) ||
+         (character_text.type == PP_VARTYPE_STRING));
+  // Serialize the character_text Var.
+  uint32_t text_size = kMaxVarSize;
+  nacl::scoped_array<char> text_bytes(Serialize(&character_text, 1,
+                                                &text_size));
+  int32_t handled;
+//  char* event_data = const_cast<char*>(reinterpret_cast<const char*>(data));

[sehr (please use chromium), 2011/07/20 00:33:41]

Why is this commented out?  Remove it.

[dmichael (off chromium), 2011/07/20 03:50:22]

Oops, done.

+  NaClSrpcError srpc_result =
+      PppInputEventRpcClient::PPP_InputEvent_HandleInputEvent(
+          GetMainSrpcChannel(instance),
+          instance,
+          input_event,
+          sizeof(data),
+          reinterpret_cast<char*>(&data),
+          text_size,
+          text_bytes.get(),
+          &handled);
+  DebugPrintf("PPP_Instance::HandleInputEvent: %s\n",
+              NaClSrpcErrorString(srpc_result));
+  if (srpc_result != NACL_SRPC_RESULT_OK) {
+    return PP_FALSE;
+  }
+  if (ignore_return_value) {
+    return PP_FALSE;
+  }
+  PP_Bool handled_bool = static_cast<PP_Bool>(handled);
+  // The 'handled' int should only ever have a value matching one of PP_FALSE
+  // or PP_TRUE. Otherwise, there's an error in the proxy.
+  DCHECK((handled_bool == PP_FALSE) || (handled_bool == PP_TRUE));
+  return handled_bool;
+}
+
+}  // namespace
+
+// static
+void BrowserInputEvent::InputEventsRequested(PP_Instance instance,
+                                             uint32_t event_classes,
+                                             bool filtering) {
+  RegisteredTypes& registered_types = instance_registered_map()[instance];
+  if (filtering) {
+    registered_types.filtering |= event_classes;
+    registered_types.nonfiltering &= ~event_classes;
+  } else {
+    // Don't allow unfiltered keyboard access.
+    uint32_t fixed_classes =
+        event_classes & ~uint32_t(PP_INPUTEVENT_CLASS_KEYBOARD);
+    registered_types.nonfiltering |= fixed_classes;
+    registered_types.filtering &= ~fixed_classes;
+  }
+}
+
+// static
+void BrowserInputEvent::InputEventsCleared(PP_Instance instance,
+                                           uint32_t event_classes) {
+  RegisteredTypes& registered_types = instance_registered_map()[instance];
+  registered_types.filtering &= ~(event_classes);
+  registered_types.nonfiltering &= ~(event_classes);
+}
+
+// static
+void BrowserInputEvent::InstanceDestroyed(PP_Instance instance) {
+  instance_registered_map().erase(instance);
+}
+
+// static
+bool BrowserInputEvent::InputEventTypeIsRegistered(PP_Instance instance,
+                                                   PP_InputEvent_Type type) {
+  InstanceRegisteredTypesMap::const_iterator iter =
+      instance_registered_map().find(instance);
+  if (iter != instance_registered_map().end()) {
+    return ((type & iter->second.filtering) ||
+            (type & iter->second.nonfiltering));
+  }
+  return false;
+}
+
+// static
+bool BrowserInputEvent::InputEventTypeIsFiltered(PP_Instance instance,
+                                                 PP_InputEvent_Type type) {
+  InstanceRegisteredTypesMap::const_iterator iter =
+      instance_registered_map().find(instance);
+  if (iter != instance_registered_map().end()) {
+    return (type & iter->second.filtering);
+  }
+  return false;
+}
+
+const PPP_InputEvent* BrowserInputEvent::GetInterface() {
+  static const PPP_InputEvent interface = {
+    HandleInputEvent
+  };
+  return &interface;
+}
+
+}  // namespace ppapi_proxy