1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/renderer/pepper/event_conversion.h"
6
7 #include <map>
8
9 #include "base/basictypes.h"
10 #include "base/i18n/char_iterator.h"
11 #include "base/logging.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/strings/string_util.h"
14 #include "base/strings/stringprintf.h"
15 #include "base/strings/utf_string_conversion_utils.h"
16 #include "base/strings/utf_string_conversions.h"
17 #include "content/renderer/pepper/common.h"
18 #include "content/renderer/pepper/usb_key_code_conversion.h"
19 #include "ppapi/c/pp_input_event.h"
20 #include "ppapi/shared_impl/ppb_input_event_shared.h"
21 #include "ppapi/shared_impl/time_conversion.h"
22 #include "third_party/WebKit/public/platform/WebGamepads.h"
23 #include "third_party/WebKit/public/platform/WebString.h"
24 #include "third_party/WebKit/public/web/WebInputEvent.h"
25
26 using ppapi::EventTimeToPPTimeTicks;
27 using ppapi::InputEventData;
28 using ppapi::PPTimeTicksToEventTime;
29 using blink::WebInputEvent;
30 using blink::WebKeyboardEvent;
31 using blink::WebMouseEvent;
32 using blink::WebMouseWheelEvent;
33 using blink::WebString;
34 using blink::WebTouchEvent;
35 using blink::WebTouchPoint;
36 using blink::WebUChar;
37
38 namespace content {
39
40 namespace {
41
42 // Verify the modifier flags WebKit uses match the Pepper ones. If these start
43 // not matching, we'll need to write conversion code to preserve the Pepper
44 // values (since plugins will be depending on them).
45 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_SHIFTKEY) ==
46 static_cast<int>(WebInputEvent::ShiftKey),
47 ShiftKeyMatches);
48 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_CONTROLKEY) ==
49 static_cast<int>(WebInputEvent::ControlKey),
50 ControlKeyMatches);
51 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ALTKEY) ==
52 static_cast<int>(WebInputEvent::AltKey),
53 AltKeyMatches);
54 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_METAKEY) ==
55 static_cast<int>(WebInputEvent::MetaKey),
56 MetaKeyMatches);
57 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISKEYPAD) ==
58 static_cast<int>(WebInputEvent::IsKeyPad),
59 KeyPadMatches);
60 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT) ==
61 static_cast<int>(WebInputEvent::IsAutoRepeat),
62 AutoRepeatMatches);
63 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN) ==
64 static_cast<int>(WebInputEvent::LeftButtonDown),
65 LeftButtonMatches);
66 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN) ==
67 static_cast<int>(WebInputEvent::MiddleButtonDown),
68 MiddleButtonMatches);
69 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN) ==
70 static_cast<int>(WebInputEvent::RightButtonDown),
71 RightButtonMatches);
72 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY) ==
73 static_cast<int>(WebInputEvent::CapsLockOn),
74 CapsLockMatches);
75 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_NUMLOCKKEY) ==
76 static_cast<int>(WebInputEvent::NumLockOn),
77 NumLockMatches);
78 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISLEFT) ==
79 static_cast<int>(WebInputEvent::IsLeft),
80 LeftMatches);
81 COMPILE_ASSERT(static_cast<int>(PP_INPUTEVENT_MODIFIER_ISRIGHT) ==
82 static_cast<int>(WebInputEvent::IsRight),
83 RightMatches);
84
ConvertEventTypes(WebInputEvent::Type wetype)85 PP_InputEvent_Type ConvertEventTypes(WebInputEvent::Type wetype) {
86 switch (wetype) {
87 case WebInputEvent::MouseDown:
88 return PP_INPUTEVENT_TYPE_MOUSEDOWN;
89 case WebInputEvent::MouseUp:
90 return PP_INPUTEVENT_TYPE_MOUSEUP;
91 case WebInputEvent::MouseMove:
92 return PP_INPUTEVENT_TYPE_MOUSEMOVE;
93 case WebInputEvent::MouseEnter:
94 return PP_INPUTEVENT_TYPE_MOUSEENTER;
95 case WebInputEvent::MouseLeave:
96 return PP_INPUTEVENT_TYPE_MOUSELEAVE;
97 case WebInputEvent::ContextMenu:
98 return PP_INPUTEVENT_TYPE_CONTEXTMENU;
99 case WebInputEvent::MouseWheel:
100 return PP_INPUTEVENT_TYPE_WHEEL;
101 case WebInputEvent::RawKeyDown:
102 return PP_INPUTEVENT_TYPE_RAWKEYDOWN;
103 case WebInputEvent::KeyDown:
104 return PP_INPUTEVENT_TYPE_KEYDOWN;
105 case WebInputEvent::KeyUp:
106 return PP_INPUTEVENT_TYPE_KEYUP;
107 case WebInputEvent::Char:
108 return PP_INPUTEVENT_TYPE_CHAR;
109 case WebInputEvent::TouchStart:
110 return PP_INPUTEVENT_TYPE_TOUCHSTART;
111 case WebInputEvent::TouchMove:
112 return PP_INPUTEVENT_TYPE_TOUCHMOVE;
113 case WebInputEvent::TouchEnd:
114 return PP_INPUTEVENT_TYPE_TOUCHEND;
115 case WebInputEvent::TouchCancel:
116 return PP_INPUTEVENT_TYPE_TOUCHCANCEL;
117 case WebInputEvent::Undefined:
118 default:
119 return PP_INPUTEVENT_TYPE_UNDEFINED;
120 }
121 }
122
123 // Generates a PP_InputEvent with the fields common to all events, as well as
124 // the event type from the given web event. Event-specific fields will be zero
125 // initialized.
GetEventWithCommonFieldsAndType(const WebInputEvent & web_event)126 InputEventData GetEventWithCommonFieldsAndType(const WebInputEvent& web_event) {
127 InputEventData result;
128 result.event_type = ConvertEventTypes(web_event.type);
129 result.event_time_stamp = EventTimeToPPTimeTicks(web_event.timeStampSeconds);
130 result.usb_key_code = 0;
131 return result;
132 }
133
AppendKeyEvent(const WebInputEvent & event,std::vector<InputEventData> * result_events)134 void AppendKeyEvent(const WebInputEvent& event,
135 std::vector<InputEventData>* result_events) {
136 const WebKeyboardEvent& key_event =
137 static_cast<const WebKeyboardEvent&>(event);
138 InputEventData result = GetEventWithCommonFieldsAndType(event);
139 result.event_modifiers = key_event.modifiers;
140 result.key_code = key_event.windowsKeyCode;
141 result.usb_key_code = UsbKeyCodeForKeyboardEvent(key_event);
142 result.code = CodeForKeyboardEvent(key_event);
143 result_events->push_back(result);
144 }
145
AppendCharEvent(const WebInputEvent & event,std::vector<InputEventData> * result_events)146 void AppendCharEvent(const WebInputEvent& event,
147 std::vector<InputEventData>* result_events) {
148 const WebKeyboardEvent& key_event =
149 static_cast<const WebKeyboardEvent&>(event);
150
151 // This is a bit complex, the input event will normally just have one 16-bit
152 // character in it, but may be zero or more than one. The text array is
153 // just padded with 0 values for the unused ones, but is not necessarily
154 // null-terminated.
155 //
156 // Here we see how many UTF-16 characters we have.
157 size_t utf16_char_count = 0;
158 while (utf16_char_count < WebKeyboardEvent::textLengthCap &&
159 key_event.text[utf16_char_count])
160 utf16_char_count++;
161
162 // Make a separate InputEventData for each Unicode character in the input.
163 base::i18n::UTF16CharIterator iter(key_event.text, utf16_char_count);
164 while (!iter.end()) {
165 InputEventData result = GetEventWithCommonFieldsAndType(event);
166 result.event_modifiers = key_event.modifiers;
167 base::WriteUnicodeCharacter(iter.get(), &result.character_text);
168
169 result_events->push_back(result);
170 iter.Advance();
171 }
172 }
173
AppendMouseEvent(const WebInputEvent & event,std::vector<InputEventData> * result_events)174 void AppendMouseEvent(const WebInputEvent& event,
175 std::vector<InputEventData>* result_events) {
176 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonNone) ==
177 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
178 MouseNone);
179 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonLeft) ==
180 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
181 MouseLeft);
182 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonRight) ==
183 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
184 MouseRight);
185 COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonMiddle) ==
186 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
187 MouseMiddle);
188
189 const WebMouseEvent& mouse_event =
190 static_cast<const WebMouseEvent&>(event);
191 InputEventData result = GetEventWithCommonFieldsAndType(event);
192 result.event_modifiers = mouse_event.modifiers;
193 if (mouse_event.type == WebInputEvent::MouseDown ||
194 mouse_event.type == WebInputEvent::MouseMove ||
195 mouse_event.type == WebInputEvent::MouseUp) {
196 result.mouse_button =
197 static_cast<PP_InputEvent_MouseButton>(mouse_event.button);
198 }
199 result.mouse_position.x = mouse_event.x;
200 result.mouse_position.y = mouse_event.y;
201 result.mouse_click_count = mouse_event.clickCount;
202 result.mouse_movement.x = mouse_event.movementX;
203 result.mouse_movement.y = mouse_event.movementY;
204 result_events->push_back(result);
205 }
206
AppendMouseWheelEvent(const WebInputEvent & event,std::vector<InputEventData> * result_events)207 void AppendMouseWheelEvent(const WebInputEvent& event,
208 std::vector<InputEventData>* result_events) {
209 const WebMouseWheelEvent& mouse_wheel_event =
210 static_cast<const WebMouseWheelEvent&>(event);
211 InputEventData result = GetEventWithCommonFieldsAndType(event);
212 result.event_modifiers = mouse_wheel_event.modifiers;
213 result.wheel_delta.x = mouse_wheel_event.deltaX;
214 result.wheel_delta.y = mouse_wheel_event.deltaY;
215 result.wheel_ticks.x = mouse_wheel_event.wheelTicksX;
216 result.wheel_ticks.y = mouse_wheel_event.wheelTicksY;
217 result.wheel_scroll_by_page = !!mouse_wheel_event.scrollByPage;
218 result_events->push_back(result);
219 }
220
SetPPTouchPoints(const WebTouchPoint * touches,uint32_t touches_length,std::vector<PP_TouchPoint> * result)221 void SetPPTouchPoints(const WebTouchPoint* touches, uint32_t touches_length,
222 std::vector<PP_TouchPoint>* result) {
223 for (uint32_t i = 0; i < touches_length; i++) {
224 const WebTouchPoint& touch_point = touches[i];
225 PP_TouchPoint pp_pt;
226 pp_pt.id = touch_point.id;
227 pp_pt.position.x = touch_point.position.x;
228 pp_pt.position.y = touch_point.position.y;
229 pp_pt.radius.x = touch_point.radiusX;
230 pp_pt.radius.y = touch_point.radiusY;
231 pp_pt.rotation_angle = touch_point.rotationAngle;
232 pp_pt.pressure = touch_point.force;
233 result->push_back(pp_pt);
234 }
235 }
236
AppendTouchEvent(const WebInputEvent & event,std::vector<InputEventData> * result_events)237 void AppendTouchEvent(const WebInputEvent& event,
238 std::vector<InputEventData>* result_events) {
239 const WebTouchEvent& touch_event =
240 reinterpret_cast<const WebTouchEvent&>(event);
241
242 InputEventData result = GetEventWithCommonFieldsAndType(event);
243 SetPPTouchPoints(touch_event.touches, touch_event.touchesLength,
244 &result.touches);
245 SetPPTouchPoints(touch_event.changedTouches, touch_event.changedTouchesLength,
246 &result.changed_touches);
247 SetPPTouchPoints(touch_event.targetTouches, touch_event.targetTouchesLength,
248 &result.target_touches);
249
250 result_events->push_back(result);
251 }
252
253 // Structure used to map touch point id's to touch states. Since the pepper
254 // touch event structure does not have states for individual touch points and
255 // instead relies on the event type in combination with the set of touch lists,
256 // we have to set the state for the changed touches to be the same as the event
257 // type and all others to be 'stationary.'
258 typedef std::map<uint32_t, WebTouchPoint::State> TouchStateMap;
259
SetWebTouchPoints(const std::vector<PP_TouchPoint> & pp_touches,const TouchStateMap & states_map,WebTouchPoint * web_touches,uint32_t * web_touches_length)260 void SetWebTouchPoints(const std::vector<PP_TouchPoint>& pp_touches,
261 const TouchStateMap& states_map,
262 WebTouchPoint* web_touches,
263 uint32_t* web_touches_length) {
264
265 for (uint32_t i = 0; i < pp_touches.size() &&
266 i < WebTouchEvent::touchesLengthCap; i++) {
267 WebTouchPoint pt;
268 const PP_TouchPoint& pp_pt = pp_touches[i];
269 pt.id = pp_pt.id;
270
271 if (states_map.find(pt.id) == states_map.end())
272 pt.state = WebTouchPoint::StateStationary;
273 else
274 pt.state = states_map.find(pt.id)->second;
275
276 pt.position.x = pp_pt.position.x;
277 pt.position.y = pp_pt.position.y;
278 // TODO bug:http://code.google.com/p/chromium/issues/detail?id=93902
279 pt.screenPosition.x = 0;
280 pt.screenPosition.y = 0;
281 pt.force = pp_pt.pressure;
282 pt.radiusX = pp_pt.radius.x;
283 pt.radiusY = pp_pt.radius.y;
284 pt.rotationAngle = pp_pt.rotation_angle;
285 web_touches[i] = pt;
286 (*web_touches_length)++;
287 }
288 }
289
BuildTouchEvent(const InputEventData & event)290 WebTouchEvent* BuildTouchEvent(const InputEventData& event) {
291 WebTouchEvent* web_event = new WebTouchEvent();
292 WebTouchPoint::State state = WebTouchPoint::StateUndefined;
293 switch (event.event_type) {
294 case PP_INPUTEVENT_TYPE_TOUCHSTART:
295 web_event->type = WebInputEvent::TouchStart;
296 state = WebTouchPoint::StatePressed;
297 break;
298 case PP_INPUTEVENT_TYPE_TOUCHMOVE:
299 web_event->type = WebInputEvent::TouchMove;
300 state = WebTouchPoint::StateMoved;
301 break;
302 case PP_INPUTEVENT_TYPE_TOUCHEND:
303 web_event->type = WebInputEvent::TouchEnd;
304 state = WebTouchPoint::StateReleased;
305 break;
306 case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
307 web_event->type = WebInputEvent::TouchCancel;
308 state = WebTouchPoint::StateCancelled;
309 break;
310 default:
311 NOTREACHED();
312 }
313
314 TouchStateMap states_map;
315 for (uint32_t i = 0; i < event.changed_touches.size(); i++)
316 states_map[event.changed_touches[i].id] = state;
317
318 web_event->timeStampSeconds = PPTimeTicksToEventTime(event.event_time_stamp);
319
320 SetWebTouchPoints(event.changed_touches, states_map,
321 web_event->changedTouches,
322 &web_event->changedTouchesLength);
323
324 SetWebTouchPoints(event.touches, states_map, web_event->touches,
325 &web_event->touchesLength);
326
327 SetWebTouchPoints(event.target_touches, states_map, web_event->targetTouches,
328 &web_event->targetTouchesLength);
329
330 if (web_event->type == WebInputEvent::TouchEnd ||
331 web_event->type == WebInputEvent::TouchCancel) {
332 SetWebTouchPoints(event.changed_touches, states_map,
333 web_event->touches, &web_event->touchesLength);
334 SetWebTouchPoints(event.changed_touches, states_map,
335 web_event->targetTouches,
336 &web_event->targetTouchesLength);
337 }
338
339 return web_event;
340 }
341
BuildKeyEvent(const InputEventData & event)342 WebKeyboardEvent* BuildKeyEvent(const InputEventData& event) {
343 WebKeyboardEvent* key_event = new WebKeyboardEvent();
344 switch (event.event_type) {
345 case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
346 key_event->type = WebInputEvent::RawKeyDown;
347 break;
348 case PP_INPUTEVENT_TYPE_KEYDOWN:
349 key_event->type = WebInputEvent::KeyDown;
350 break;
351 case PP_INPUTEVENT_TYPE_KEYUP:
352 key_event->type = WebInputEvent::KeyUp;
353 break;
354 default:
355 NOTREACHED();
356 }
357 key_event->timeStampSeconds = PPTimeTicksToEventTime(event.event_time_stamp);
358 key_event->modifiers = event.event_modifiers;
359 key_event->windowsKeyCode = event.key_code;
360 key_event->setKeyIdentifierFromWindowsKeyCode();
361 return key_event;
362 }
363
BuildCharEvent(const InputEventData & event)364 WebKeyboardEvent* BuildCharEvent(const InputEventData& event) {
365 WebKeyboardEvent* key_event = new WebKeyboardEvent();
366 key_event->type = WebInputEvent::Char;
367 key_event->timeStampSeconds = PPTimeTicksToEventTime(event.event_time_stamp);
368 key_event->modifiers = event.event_modifiers;
369
370 // Make sure to not read beyond the buffer in case some bad code doesn't
371 // NULL-terminate it (this is called from plugins).
372 size_t text_length_cap = WebKeyboardEvent::textLengthCap;
373 base::string16 text16 = UTF8ToUTF16(event.character_text);
374
375 memset(key_event->text, 0, text_length_cap);
376 memset(key_event->unmodifiedText, 0, text_length_cap);
377 for (size_t i = 0;
378 i < std::min(text_length_cap, text16.size());
379 ++i)
380 key_event->text[i] = text16[i];
381 return key_event;
382 }
383
BuildMouseEvent(const InputEventData & event)384 WebMouseEvent* BuildMouseEvent(const InputEventData& event) {
385 WebMouseEvent* mouse_event = new WebMouseEvent();
386 switch (event.event_type) {
387 case PP_INPUTEVENT_TYPE_MOUSEDOWN:
388 mouse_event->type = WebInputEvent::MouseDown;
389 break;
390 case PP_INPUTEVENT_TYPE_MOUSEUP:
391 mouse_event->type = WebInputEvent::MouseUp;
392 break;
393 case PP_INPUTEVENT_TYPE_MOUSEMOVE:
394 mouse_event->type = WebInputEvent::MouseMove;
395 break;
396 case PP_INPUTEVENT_TYPE_MOUSEENTER:
397 mouse_event->type = WebInputEvent::MouseEnter;
398 break;
399 case PP_INPUTEVENT_TYPE_MOUSELEAVE:
400 mouse_event->type = WebInputEvent::MouseLeave;
401 break;
402 case PP_INPUTEVENT_TYPE_CONTEXTMENU:
403 mouse_event->type = WebInputEvent::ContextMenu;
404 break;
405 default:
406 NOTREACHED();
407 }
408 mouse_event->timeStampSeconds =
409 PPTimeTicksToEventTime(event.event_time_stamp);
410 mouse_event->modifiers = event.event_modifiers;
411 mouse_event->button =
412 static_cast<WebMouseEvent::Button>(event.mouse_button);
413 if (mouse_event->type == WebInputEvent::MouseMove) {
414 if (mouse_event->modifiers & WebInputEvent::LeftButtonDown)
415 mouse_event->button = WebMouseEvent::ButtonLeft;
416 else if (mouse_event->modifiers & WebInputEvent::MiddleButtonDown)
417 mouse_event->button = WebMouseEvent::ButtonMiddle;
418 else if (mouse_event->modifiers & WebInputEvent::RightButtonDown)
419 mouse_event->button = WebMouseEvent::ButtonRight;
420 }
421 mouse_event->x = event.mouse_position.x;
422 mouse_event->y = event.mouse_position.y;
423 mouse_event->clickCount = event.mouse_click_count;
424 mouse_event->movementX = event.mouse_movement.x;
425 mouse_event->movementY = event.mouse_movement.y;
426 return mouse_event;
427 }
428
BuildMouseWheelEvent(const InputEventData & event)429 WebMouseWheelEvent* BuildMouseWheelEvent(const InputEventData& event) {
430 WebMouseWheelEvent* mouse_wheel_event = new WebMouseWheelEvent();
431 mouse_wheel_event->type = WebInputEvent::MouseWheel;
432 mouse_wheel_event->timeStampSeconds =
433 PPTimeTicksToEventTime(event.event_time_stamp);
434 mouse_wheel_event->modifiers = event.event_modifiers;
435 mouse_wheel_event->deltaX = event.wheel_delta.x;
436 mouse_wheel_event->deltaY = event.wheel_delta.y;
437 mouse_wheel_event->wheelTicksX = event.wheel_ticks.x;
438 mouse_wheel_event->wheelTicksY = event.wheel_ticks.y;
439 mouse_wheel_event->scrollByPage = event.wheel_scroll_by_page;
440 return mouse_wheel_event;
441 }
442
443 #if !defined(OS_WIN)
444 #define VK_RETURN 0x0D
445
446 #define VK_PRIOR 0x21
447 #define VK_NEXT 0x22
448 #define VK_END 0x23
449 #define VK_HOME 0x24
450 #define VK_LEFT 0x25
451 #define VK_UP 0x26
452 #define VK_RIGHT 0x27
453 #define VK_DOWN 0x28
454 #define VK_SNAPSHOT 0x2C
455 #define VK_INSERT 0x2D
456 #define VK_DELETE 0x2E
457
458 #define VK_APPS 0x5D
459
460 #define VK_F1 0x70
461 #endif
462
463 // Convert a character string to a Windows virtual key code. Adapted from
464 // src/third_party/WebKit/Tools/DumpRenderTree/chromium/EventSender.cpp. This
465 // is used by CreateSimulatedWebInputEvents to convert keyboard events.
GetKeyCode(const std::string & char_text,WebUChar * code,WebUChar * text,bool * needs_shift_modifier,bool * generate_char)466 void GetKeyCode(const std::string& char_text,
467 WebUChar* code,
468 WebUChar* text,
469 bool* needs_shift_modifier,
470 bool* generate_char) {
471 WebUChar vk_code = 0;
472 WebUChar vk_text = 0;
473 *needs_shift_modifier = false;
474 *generate_char = false;
475 if ("\n" == char_text) {
476 vk_text = vk_code = VK_RETURN;
477 *generate_char = true;
478 } else if ("rightArrow" == char_text) {
479 vk_code = VK_RIGHT;
480 } else if ("downArrow" == char_text) {
481 vk_code = VK_DOWN;
482 } else if ("leftArrow" == char_text) {
483 vk_code = VK_LEFT;
484 } else if ("upArrow" == char_text) {
485 vk_code = VK_UP;
486 } else if ("insert" == char_text) {
487 vk_code = VK_INSERT;
488 } else if ("delete" == char_text) {
489 vk_code = VK_DELETE;
490 } else if ("pageUp" == char_text) {
491 vk_code = VK_PRIOR;
492 } else if ("pageDown" == char_text) {
493 vk_code = VK_NEXT;
494 } else if ("home" == char_text) {
495 vk_code = VK_HOME;
496 } else if ("end" == char_text) {
497 vk_code = VK_END;
498 } else if ("printScreen" == char_text) {
499 vk_code = VK_SNAPSHOT;
500 } else if ("menu" == char_text) {
501 vk_code = VK_APPS;
502 } else {
503 // Compare the input string with the function-key names defined by the
504 // DOM spec (i.e. "F1",...,"F24").
505 for (int i = 1; i <= 24; ++i) {
506 std::string functionKeyName = base::StringPrintf("F%d", i);
507 if (functionKeyName == char_text) {
508 vk_code = VK_F1 + (i - 1);
509 break;
510 }
511 }
512 if (!vk_code) {
513 WebString web_char_text =
514 WebString::fromUTF8(char_text.data(), char_text.size());
515 DCHECK_EQ(web_char_text.length(), 1U);
516 vk_text = vk_code = web_char_text.at(0);
517 *needs_shift_modifier =
518 (vk_code & 0xFF) >= 'A' && (vk_code & 0xFF) <= 'Z';
519 if ((vk_code & 0xFF) >= 'a' && (vk_code & 0xFF) <= 'z')
520 vk_code -= 'a' - 'A';
521 *generate_char = true;
522 }
523 }
524
525 *code = vk_code;
526 *text = vk_text;
527 }
528
529 } // namespace
530
CreateInputEventData(const WebInputEvent & event,std::vector<InputEventData> * result)531 void CreateInputEventData(const WebInputEvent& event,
532 std::vector<InputEventData>* result) {
533 result->clear();
534
535 switch (event.type) {
536 case WebInputEvent::MouseDown:
537 case WebInputEvent::MouseUp:
538 case WebInputEvent::MouseMove:
539 case WebInputEvent::MouseEnter:
540 case WebInputEvent::MouseLeave:
541 case WebInputEvent::ContextMenu:
542 AppendMouseEvent(event, result);
543 break;
544 case WebInputEvent::MouseWheel:
545 AppendMouseWheelEvent(event, result);
546 break;
547 case WebInputEvent::RawKeyDown:
548 case WebInputEvent::KeyDown:
549 case WebInputEvent::KeyUp:
550 AppendKeyEvent(event, result);
551 break;
552 case WebInputEvent::Char:
553 AppendCharEvent(event, result);
554 break;
555 case WebInputEvent::TouchStart:
556 case WebInputEvent::TouchMove:
557 case WebInputEvent::TouchEnd:
558 case WebInputEvent::TouchCancel:
559 AppendTouchEvent(event, result);
560 break;
561 case WebInputEvent::Undefined:
562 default:
563 break;
564 }
565 }
566
CreateWebInputEvent(const InputEventData & event)567 WebInputEvent* CreateWebInputEvent(const InputEventData& event) {
568 scoped_ptr<WebInputEvent> web_input_event;
569 switch (event.event_type) {
570 case PP_INPUTEVENT_TYPE_UNDEFINED:
571 return NULL;
572 case PP_INPUTEVENT_TYPE_MOUSEDOWN:
573 case PP_INPUTEVENT_TYPE_MOUSEUP:
574 case PP_INPUTEVENT_TYPE_MOUSEMOVE:
575 case PP_INPUTEVENT_TYPE_MOUSEENTER:
576 case PP_INPUTEVENT_TYPE_MOUSELEAVE:
577 case PP_INPUTEVENT_TYPE_CONTEXTMENU:
578 web_input_event.reset(BuildMouseEvent(event));
579 break;
580 case PP_INPUTEVENT_TYPE_WHEEL:
581 web_input_event.reset(BuildMouseWheelEvent(event));
582 break;
583 case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
584 case PP_INPUTEVENT_TYPE_KEYDOWN:
585 case PP_INPUTEVENT_TYPE_KEYUP:
586 web_input_event.reset(BuildKeyEvent(event));
587 break;
588 case PP_INPUTEVENT_TYPE_CHAR:
589 web_input_event.reset(BuildCharEvent(event));
590 break;
591 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START:
592 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE:
593 case PP_INPUTEVENT_TYPE_IME_COMPOSITION_END:
594 case PP_INPUTEVENT_TYPE_IME_TEXT:
595 // TODO(kinaba) implement in WebKit an event structure to handle
596 // composition events.
597 NOTREACHED();
598 break;
599 case PP_INPUTEVENT_TYPE_TOUCHSTART:
600 case PP_INPUTEVENT_TYPE_TOUCHMOVE:
601 case PP_INPUTEVENT_TYPE_TOUCHEND:
602 case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
603 web_input_event.reset(BuildTouchEvent(event));
604 break;
605 }
606
607 return web_input_event.release();
608 }
609
610 // Generate a coherent sequence of input events to simulate a user event.
611 // From src/third_party/WebKit/Tools/DumpRenderTree/chromium/EventSender.cpp.
CreateSimulatedWebInputEvents(const ppapi::InputEventData & event,int plugin_x,int plugin_y)612 std::vector<linked_ptr<WebInputEvent> > CreateSimulatedWebInputEvents(
613 const ppapi::InputEventData& event,
614 int plugin_x,
615 int plugin_y) {
616 std::vector<linked_ptr<WebInputEvent> > events;
617 linked_ptr<WebInputEvent> original_event(CreateWebInputEvent(event));
618
619 switch (event.event_type) {
620 case PP_INPUTEVENT_TYPE_MOUSEDOWN:
621 case PP_INPUTEVENT_TYPE_MOUSEUP:
622 case PP_INPUTEVENT_TYPE_MOUSEMOVE:
623 case PP_INPUTEVENT_TYPE_MOUSEENTER:
624 case PP_INPUTEVENT_TYPE_MOUSELEAVE:
625 case PP_INPUTEVENT_TYPE_TOUCHSTART:
626 case PP_INPUTEVENT_TYPE_TOUCHMOVE:
627 case PP_INPUTEVENT_TYPE_TOUCHEND:
628 case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
629 events.push_back(original_event);
630 break;
631
632 case PP_INPUTEVENT_TYPE_WHEEL: {
633 WebMouseWheelEvent* web_mouse_wheel_event =
634 static_cast<WebMouseWheelEvent*>(original_event.get());
635 web_mouse_wheel_event->x = plugin_x;
636 web_mouse_wheel_event->y = plugin_y;
637 events.push_back(original_event);
638 break;
639 }
640
641 case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
642 case PP_INPUTEVENT_TYPE_KEYDOWN:
643 case PP_INPUTEVENT_TYPE_KEYUP: {
644 // Windows key down events should always be "raw" to avoid an ASSERT.
645 #if defined(OS_WIN)
646 WebKeyboardEvent* web_keyboard_event =
647 static_cast<WebKeyboardEvent*>(original_event.get());
648 if (web_keyboard_event->type == WebInputEvent::KeyDown)
649 web_keyboard_event->type = WebInputEvent::RawKeyDown;
650 #endif
651 events.push_back(original_event);
652 break;
653 }
654
655 case PP_INPUTEVENT_TYPE_CHAR: {
656 WebKeyboardEvent* web_char_event =
657 static_cast<WebKeyboardEvent*>(original_event.get());
658
659 WebUChar code = 0, text = 0;
660 bool needs_shift_modifier = false, generate_char = false;
661 GetKeyCode(event.character_text,
662 &code,
663 &text,
664 &needs_shift_modifier,
665 &generate_char);
666
667 // Synthesize key down and key up events in all cases.
668 scoped_ptr<WebKeyboardEvent> key_down_event(new WebKeyboardEvent());
669 scoped_ptr<WebKeyboardEvent> key_up_event(new WebKeyboardEvent());
670
671 key_down_event->type = WebInputEvent::RawKeyDown;
672 key_down_event->windowsKeyCode = code;
673 key_down_event->nativeKeyCode = code;
674 if (needs_shift_modifier)
675 key_down_event->modifiers |= WebInputEvent::ShiftKey;
676
677 // If a char event is needed, set the text fields.
678 if (generate_char) {
679 key_down_event->text[0] = text;
680 key_down_event->unmodifiedText[0] = text;
681 }
682 // Convert the key code to a string identifier.
683 key_down_event->setKeyIdentifierFromWindowsKeyCode();
684
685 *key_up_event = *web_char_event = *key_down_event;
686
687 events.push_back(linked_ptr<WebInputEvent>(key_down_event.release()));
688
689 if (generate_char) {
690 web_char_event->type = WebInputEvent::Char;
691 web_char_event->keyIdentifier[0] = '\0';
692 events.push_back(original_event);
693 }
694
695 key_up_event->type = WebInputEvent::KeyUp;
696 events.push_back(linked_ptr<WebInputEvent>(key_up_event.release()));
697 break;
698 }
699
700 default:
701 break;
702 }
703 return events;
704 }
705
ClassifyInputEvent(WebInputEvent::Type type)706 PP_InputEvent_Class ClassifyInputEvent(WebInputEvent::Type type) {
707 switch (type) {
708 case WebInputEvent::MouseDown:
709 case WebInputEvent::MouseUp:
710 case WebInputEvent::MouseMove:
711 case WebInputEvent::MouseEnter:
712 case WebInputEvent::MouseLeave:
713 case WebInputEvent::ContextMenu:
714 return PP_INPUTEVENT_CLASS_MOUSE;
715 case WebInputEvent::MouseWheel:
716 return PP_INPUTEVENT_CLASS_WHEEL;
717 case WebInputEvent::RawKeyDown:
718 case WebInputEvent::KeyDown:
719 case WebInputEvent::KeyUp:
720 case WebInputEvent::Char:
721 return PP_INPUTEVENT_CLASS_KEYBOARD;
722 case WebInputEvent::TouchCancel:
723 case WebInputEvent::TouchEnd:
724 case WebInputEvent::TouchMove:
725 case WebInputEvent::TouchStart:
726 return PP_INPUTEVENT_CLASS_TOUCH;
727 case WebInputEvent::Undefined:
728 default:
729 NOTREACHED();
730 return PP_InputEvent_Class(0);
731 }
732 }
733
734 } // namespace content
735