src/content/renderer/pepper/event_conversion.cc

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