Eraser tool type plumbing from ui/events to web events and PPAPI.

content/renderer/pepper/event_conversion.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 "content/renderer/pepper/event_conversion.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 101 matching lines @@
     case WebInputEvent::TouchEnd:
       return PP_INPUTEVENT_TYPE_TOUCHEND;
     case WebInputEvent::TouchCancel:
       return PP_INPUTEVENT_TYPE_TOUCHCANCEL;
     case WebInputEvent::Undefined:
     default:
       return PP_INPUTEVENT_TYPE_UNDEFINED;
   }
 }
 
+// Converts WebInputEvent::Modifiers flags to PP_InputEvent_Modifier.
+int ConvertEventModifiers(int modifiers) {
+  return modifiers & (PP_INPUTEVENT_MODIFIER_CONTROLKEY |
+                      PP_INPUTEVENT_MODIFIER_ALTKEY |
+                      PP_INPUTEVENT_MODIFIER_METAKEY |
+                      PP_INPUTEVENT_MODIFIER_ISKEYPAD |
+                      PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT |
+                      PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN |
+                      PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN |
+                      PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN |
+                      PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY |
+                      PP_INPUTEVENT_MODIFIER_NUMLOCKKEY |
+                      PP_INPUTEVENT_MODIFIER_ISLEFT |
+                      PP_INPUTEVENT_MODIFIER_ISRIGHT);
+}
+
 // Generates a PP_InputEvent with the fields common to all events, as well as
 // the event type from the given web event. Event-specific fields will be zero
 // initialized.
 InputEventData GetEventWithCommonFieldsAndType(const WebInputEvent& web_event) {
   InputEventData result;
   result.event_type = ConvertEventTypes(web_event.type);
   result.event_time_stamp = web_event.timeStampSeconds;
   return result;
 }
 
 void AppendKeyEvent(const WebInputEvent& event,
                     std::vector<InputEventData>* result_events) {
   const WebKeyboardEvent& key_event =
       static_cast<const WebKeyboardEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = key_event.modifiers;
+  result.event_modifiers = ConvertEventModifiers(key_event.modifiers);
   result.key_code = key_event.windowsKeyCode;
   result.code = ui::KeycodeConverter::DomCodeToCodeString(
       static_cast<ui::DomCode>(key_event.domCode));
   result_events->push_back(result);
 }
 
 void AppendCharEvent(const WebInputEvent& event,
                      std::vector<InputEventData>* result_events) {
   const WebKeyboardEvent& key_event =
       static_cast<const WebKeyboardEvent&>(event);
 
   // This is a bit complex, the input event will normally just have one 16-bit
   // character in it, but may be zero or more than one. The text array is
   // just padded with 0 values for the unused ones, but is not necessarily
   // null-terminated.
   //
   // Here we see how many UTF-16 characters we have.
   size_t utf16_char_count = 0;
   while (utf16_char_count < WebKeyboardEvent::textLengthCap &&
          key_event.text[utf16_char_count])
     utf16_char_count++;
 
   // Make a separate InputEventData for each Unicode character in the input.
   base::i18n::UTF16CharIterator iter(key_event.text, utf16_char_count);
   while (!iter.end()) {
     InputEventData result = GetEventWithCommonFieldsAndType(event);
-    result.event_modifiers = key_event.modifiers;
+    result.event_modifiers = ConvertEventModifiers(key_event.modifiers);
     base::WriteUnicodeCharacter(iter.get(), &result.character_text);
 
     result_events->push_back(result);
     iter.Advance();
   }
 }
 
 void AppendMouseEvent(const WebInputEvent& event,
                       std::vector<InputEventData>* result_events) {
   static_assert(static_cast<int>(WebMouseEvent::Button::NoButton) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
                 "MouseNone should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Left) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
                 "MouseLeft should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Right) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
                 "MouseRight should match");
   static_assert(static_cast<int>(WebMouseEvent::Button::Middle) ==
                     static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
                 "MouseMiddle should match");
 
   const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = mouse_event.modifiers;
+  result.event_modifiers = ConvertEventModifiers(mouse_event.modifiers);
+  if (mouse_event.pointerType ==
+      blink::WebPointerProperties::PointerType::Pen) {
+    result.event_modifiers |= PP_INPUTEVENT_MODIFIER_ISPEN;
+  } else if (mouse_event.pointerType ==
+      blink::WebPointerProperties::PointerType::Eraser) {
+    result.event_modifiers |= PP_INPUTEVENT_MODIFIER_ISERASER;
+  }
   if (mouse_event.type == WebInputEvent::MouseDown ||
       mouse_event.type == WebInputEvent::MouseMove ||
       mouse_event.type == WebInputEvent::MouseUp) {
     result.mouse_button =
         static_cast<PP_InputEvent_MouseButton>(mouse_event.button);
   }
   result.mouse_position.x = mouse_event.x;
   result.mouse_position.y = mouse_event.y;
   result.mouse_click_count = mouse_event.clickCount;
   result.mouse_movement.x = mouse_event.movementX;
   result.mouse_movement.y = mouse_event.movementY;
   result_events->push_back(result);
 }
 
 void AppendMouseWheelEvent(const WebInputEvent& event,
                            std::vector<InputEventData>* result_events) {
   const WebMouseWheelEvent& mouse_wheel_event =
       static_cast<const WebMouseWheelEvent&>(event);
   InputEventData result = GetEventWithCommonFieldsAndType(event);
-  result.event_modifiers = mouse_wheel_event.modifiers;
+  result.event_modifiers = ConvertEventModifiers(mouse_wheel_event.modifiers);
   result.wheel_delta.x = mouse_wheel_event.deltaX;
   result.wheel_delta.y = mouse_wheel_event.deltaY;
   result.wheel_ticks.x = mouse_wheel_event.wheelTicksX;
   result.wheel_ticks.y = mouse_wheel_event.wheelTicksY;
   result.wheel_scroll_by_page = !!mouse_wheel_event.scrollByPage;
   result_events->push_back(result);
 }
 
 enum IncludedTouchPointTypes {
   ALL,     // All pointers targetting the plugin.
@@ skipping 520 matching lines @@
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::TouchScrollStarted:
       return PP_InputEvent_Class(0);
     default:
       CHECK(WebInputEvent::isGestureEventType(type));
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content