Add functions to generate input events to PPB_Testing_Dev. These make

webkit/plugins/ppapi/ppapi_plugin_instance.cc

Index: webkit/plugins/ppapi/ppapi_plugin_instance.cc
===================================================================
--- webkit/plugins/ppapi/ppapi_plugin_instance.cc	(revision 110385)
+++ webkit/plugins/ppapi/ppapi_plugin_instance.cc	(working copy)
@@ -100,6 +100,7 @@
 #endif
 
 using base::StringPrintf;
+using ppapi::InputEventData;
 using ppapi::InputEventImpl;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
@@ -119,8 +120,12 @@
 using WebKit::WebFrame;
 using WebKit::WebElement;
 using WebKit::WebInputEvent;
+using WebKit::WebKeyboardEvent;
+using WebKit::WebMouseWheelEvent;
 using WebKit::WebPluginContainer;
+using WebKit::WebPoint;
 using WebKit::WebString;
+using WebKit::WebUChar;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 
@@ -251,6 +256,89 @@
   return true;
 }
 
+#if !defined(OS_WIN)
+#define VK_RETURN         0x0D
+
+#define VK_PRIOR          0x21
+#define VK_NEXT           0x22
+#define VK_END            0x23
+#define VK_HOME           0x24
+#define VK_LEFT           0x25
+#define VK_UP             0x26
+#define VK_RIGHT          0x27
+#define VK_DOWN           0x28
+#define VK_SNAPSHOT       0x2C
+#define VK_INSERT         0x2D
+#define VK_DELETE         0x2E
+
+#define VK_APPS           0x5D
+
+#define VK_F1             0x70
+#endif
+
+// Convert a character string to a Windows virtual key code. Adapted from
+// src/third_party/WebKit/Tools/DumpRenderTree/chromium/EventSender.cpp. This
+// is used by SimulateInputEvent to convert keyboard events.
+void GetKeyCode(const std::string& char_text,

[dmichael (off chromium), 2011/11/17 19:27:57]

Can you put all this stuff somewhere else, like event_conversions?
ppapi_plugin_instance is already too big :-)

[bbudge, 2011/11/17 21:58:24]

Done.

+                WebUChar& code,
+                WebUChar& text,
+                bool& needs_shift_modifier,
+                bool& generate_char) {
+  code = 0;
+  text = 0;
+  needs_shift_modifier = false;
+  generate_char = false;
+  if ("\n" == char_text) {
+    text = code = VK_RETURN;
+    generate_char = true;
+  } else if ("rightArrow" == char_text) {
+    code = VK_RIGHT;
+  } else if ("downArrow" == char_text) {
+    code = VK_DOWN;
+  } else if ("leftArrow" == char_text) {
+    code = VK_LEFT;
+  } else if ("upArrow" == char_text) {
+    code = VK_UP;
+  } else if ("insert" == char_text) {
+    code = VK_INSERT;
+  } else if ("delete" == char_text) {
+    code = VK_DELETE;
+  } else if ("pageUp" == char_text) {
+    code = VK_PRIOR;
+  } else if ("pageDown" == char_text) {
+    code = VK_NEXT;
+  } else if ("home" == char_text) {
+    code = VK_HOME;
+  } else if ("end" == char_text) {
+    code = VK_END;
+  } else if ("printScreen" == char_text) {
+    code = VK_SNAPSHOT;
+  } else if ("menu" == char_text) {
+    code = VK_APPS;
+  } else {
+    // Compare the input string with the function-key names defined by the
+    // DOM spec (i.e. "F1",...,"F24").
+    for (int i = 1; i <= 24; ++i) {
+      std::string functionKeyName = base::StringPrintf("F%d", i);
+      if (functionKeyName == char_text) {
+        code = VK_F1 + (i - 1);
+        break;
+      }
+    }
+    if (!code) {
+      WebString web_char_text =
+          WebString::fromUTF8(char_text.data(), char_text.size());
+      DCHECK_EQ(web_char_text.length(), 1U);
+      text = code = web_char_text.data()[0];
+      needs_shift_modifier =
+          (code & 0xFF) >= 'A' && (code & 0xFF) <= 'Z';
+      if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
+          code -= 'a' - 'A';
+      generate_char = true;
+    }
+  }
+}
+
 }  // namespace
 
 // static
@@ -1599,6 +1687,97 @@
     plugin_mouse_lock_interface_->MouseLockLost(pp_instance());
 }
 
+void PluginInstance::SimulateInputEvent(const InputEventData& input_event) {
+  WebView* web_view = container()->element().document().frame()->view();
+  if (!web_view) {
+    NOTREACHED();
+    return;
+  }
+
+  scoped_ptr<WebInputEvent> web_input_event(CreateWebInputEvent(input_event));
+  switch (input_event.event_type) {
+    case PP_INPUTEVENT_TYPE_MOUSEDOWN:
+    case PP_INPUTEVENT_TYPE_MOUSEUP:
+    case PP_INPUTEVENT_TYPE_MOUSEMOVE:
+    case PP_INPUTEVENT_TYPE_MOUSEENTER:
+    case PP_INPUTEVENT_TYPE_MOUSELEAVE:
+      web_view->handleInputEvent(*web_input_event);
+      break;
+
+    case PP_INPUTEVENT_TYPE_WHEEL: {
+      // Mouse wheel events need a position inside the plugin area in order to
+      // be routed back to the plugin. Choose the midpoint of the plugin
+      // instance's area on screen.
+      WebMouseWheelEvent* web_mouse_wheel_event =
+          static_cast<WebMouseWheelEvent*>(web_input_event.get());
+      web_mouse_wheel_event->x = position().x() + position().width() / 2;
+      web_mouse_wheel_event->y = position().y() + position().height() / 2;
+      web_view->handleInputEvent(*web_mouse_wheel_event);
+      break;
+    }
+
+    case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYUP: {
+      WebKeyboardEvent* web_keyboard_event =
+          static_cast<WebKeyboardEvent*>(web_input_event.get());
+      // Windows key down events should always be "raw" to avoid an ASSERT.
+#if defined(OS_WIN)
+      if (web_keyboard_event->type == WebInputEvent::KeyDown)
+        web_keyboard_event->type = WebInputEvent::RawKeyDown;
+#endif
+      web_view->handleInputEvent(*web_keyboard_event);
+      break;
+    }
+
+    case PP_INPUTEVENT_TYPE_CHAR: {
+      WebKeyboardEvent* web_char_event =
+          static_cast<WebKeyboardEvent*>(web_input_event.get());
+
+      WebUChar code, text;
+      bool needs_shift_modifier, generate_char;
+      GetKeyCode(input_event.character_text,
+                 code,
+                 text,
+                 needs_shift_modifier,
+                 generate_char);
+
+      // We synthesize key down and key up events in all cases.
+      WebKeyboardEvent key_down_event, key_up_event;
+      key_down_event.type = WebInputEvent::RawKeyDown;
+      key_down_event.windowsKeyCode = code;
+      key_down_event.nativeKeyCode = code;
+      if (needs_shift_modifier)
+        key_down_event.modifiers |= WebInputEvent::ShiftKey;
+
+      // If a char event is needed, set the text fields.
+      if (generate_char) {
+          key_down_event.text[0] = text;
+          key_down_event.unmodifiedText[0] = text;
+      }
+      // Convert the key code to a string identifier.
+      key_down_event.setKeyIdentifierFromWindowsKeyCode();
+
+      key_up_event = *web_char_event = key_down_event;
+
+      web_view->handleInputEvent(key_down_event);
+
+      if (generate_char) {
+          web_char_event->type = WebInputEvent::Char;
+          web_char_event->keyIdentifier[0] = '\0';
+          web_view->handleInputEvent(*web_char_event);
+      }
+
+      key_up_event.type = WebInputEvent::KeyUp;
+      web_view->handleInputEvent(key_up_event);
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
 PPB_Instance_FunctionAPI* PluginInstance::AsPPB_Instance_FunctionAPI() {
   return this;
 }