Add functions to generate input events to PPB_Testing_Dev. These make

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 82 matching lines @@
 #include "skia/ext/vector_platform_device_emf_win.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/gdi_util.h"
 #endif
 
 #if defined(OS_MACOSX) && defined(USE_SKIA)
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 using base::StringPrintf;
+using ppapi::InputEventData;
 using ppapi::InputEventImpl;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::thunk::PPB_Instance_FunctionAPI;
 using ppapi::thunk::PPB_Surface3D_API;
 using ppapi::Var;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebConsoleMessage;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 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;
 
 namespace webkit {
 namespace ppapi {
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
     const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
@@ skipping 110 matching lines @@
                                WebKit::WebSecurityOrigin* security_origin) {
   PluginInstance* instance = HostGlobals::Get()->GetInstance(instance_id);
   if (!instance)
     return false;
 
   WebElement plugin_element = instance->container()->element();
   *security_origin = plugin_element.document().securityOrigin();
   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
 PluginInstance* PluginInstance::Create1_0(PluginDelegate* delegate,
                                           PluginModule* module,
                                           const void* ppp_instance_if_1_0) {
   const PPP_Instance_1_0* instance =
       static_cast<const PPP_Instance_1_0*>(ppp_instance_if_1_0);
   return new PluginInstance(
       delegate,
@@ skipping 1328 matching lines @@
   }
 
   PP_RunAndClearCompletionCallback(&lock_mouse_callback_, result);
 }
 
 void PluginInstance::OnMouseLockLost() {
   if (LoadMouseLockInterface())
     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;
 }
 
 PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
                                      PP_Resource device) {
   if (bound_graphics_.get()) {
     if (GetBoundGraphics2D()) {
       GetBoundGraphics2D()->BindToInstance(NULL);
     } else if (GetBoundGraphics3D()) {
@@ skipping 425 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit