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