Pull latest PPAPI. Change key handling to support the new API.

TEST=PPAPI UI tests
BUG=none
Review URL: http://codereview.chromium.org/3386019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@60258 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 204 insertions, 131 deletions

diff --git a/webkit/glue/plugins/pepper_event_conversion.cc b/webkit/glue/plugins/pepper_event_conversion.cc
index 99297e6..7c4f779 100644
--- a/webkit/glue/plugins/pepper_event_conversion.cc
+++ b/webkit/glue/plugins/pepper_event_conversion.cc
@@ -4,9 +4,13 @@
 
 #include "webkit/glue/plugins/pepper_event_conversion.h"
 
+#include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
-#include "third_party/ppapi/c/pp_event.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
+#include "base/utf_string_conversion_utils.h"
+#include "third_party/ppapi/c/pp_input_event.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 
 using WebKit::WebInputEvent;
@@ -15,132 +19,194 @@ using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace {
-// Anonymous namespace for functions converting WebInputEvent to PP_Event and
-// back.
-PP_Event_Type ConvertEventTypes(WebInputEvent::Type wetype) {
+
+PP_InputEvent_Type ConvertEventTypes(WebInputEvent::Type wetype) {
   switch (wetype) {
     case WebInputEvent::MouseDown:
-      return PP_EVENT_TYPE_MOUSEDOWN;
+      return PP_INPUTEVENT_TYPE_MOUSEDOWN;
     case WebInputEvent::MouseUp:
-      return PP_EVENT_TYPE_MOUSEUP;
+      return PP_INPUTEVENT_TYPE_MOUSEUP;
     case WebInputEvent::MouseMove:
-      return PP_EVENT_TYPE_MOUSEMOVE;
+      return PP_INPUTEVENT_TYPE_MOUSEMOVE;
     case WebInputEvent::MouseEnter:
-      return PP_EVENT_TYPE_MOUSEENTER;
+      return PP_INPUTEVENT_TYPE_MOUSEENTER;
     case WebInputEvent::MouseLeave:
-      return PP_EVENT_TYPE_MOUSELEAVE;
+      return PP_INPUTEVENT_TYPE_MOUSELEAVE;
     case WebInputEvent::MouseWheel:
-      return PP_EVENT_TYPE_MOUSEWHEEL;
+      return PP_INPUTEVENT_TYPE_MOUSEWHEEL;
     case WebInputEvent::RawKeyDown:
-      return PP_EVENT_TYPE_RAWKEYDOWN;
+      return PP_INPUTEVENT_TYPE_RAWKEYDOWN;
     case WebInputEvent::KeyDown:
-      return PP_EVENT_TYPE_KEYDOWN;
+      return PP_INPUTEVENT_TYPE_KEYDOWN;
     case WebInputEvent::KeyUp:
-      return PP_EVENT_TYPE_KEYUP;
+      return PP_INPUTEVENT_TYPE_KEYUP;
     case WebInputEvent::Char:
-      return PP_EVENT_TYPE_CHAR;
+      return PP_INPUTEVENT_TYPE_CHAR;
     case WebInputEvent::Undefined:
     default:
-      return PP_EVENT_TYPE_UNDEFINED;
+      return PP_INPUTEVENT_TYPE_UNDEFINED;
   }
 }
 
-void BuildKeyEvent(const WebInputEvent* event, PP_Event* pp_event) {
-  const WebKeyboardEvent* key_event =
-      reinterpret_cast<const WebKeyboardEvent*>(event);
-  pp_event->u.key.modifier = key_event->modifiers;
-  pp_event->u.key.normalizedKeyCode = key_event->windowsKeyCode;
+// Generates a PP_InputEvent with the fields common to all events, as well as
+// the event type from the given web event. Event-specific fields will be zero
+// initialized.
+PP_InputEvent GetPPEventWithCommonFieldsAndType(
+    const WebInputEvent& web_event) {
+  PP_InputEvent result;
+  memset(&result, 0, sizeof(PP_InputEvent));
+  result.type = ConvertEventTypes(web_event.type);
+  result.time_stamp_seconds = web_event.timeStampSeconds;
+  return result;
+}
+
+void AppendKeyEvent(const WebInputEvent& event,
+                    std::vector<PP_InputEvent>* pp_events) {
+  const WebKeyboardEvent& key_event =
+      reinterpret_cast<const WebKeyboardEvent&>(event);
+  PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event);
+  result.u.key.modifier = key_event.modifiers;
+  result.u.key.key_code = key_event.windowsKeyCode;
+  pp_events->push_back(result);
 }
 
-void BuildCharEvent(const WebInputEvent* event, PP_Event* pp_event) {
-  const WebKeyboardEvent* key_event =
-      reinterpret_cast<const WebKeyboardEvent*>(event);
-  pp_event->u.character.modifier = key_event->modifiers;
-  // For consistency, check that the sizes of the texts agree.
-  DCHECK(sizeof(pp_event->u.character.text) == sizeof(key_event->text));
-  DCHECK(sizeof(pp_event->u.character.unmodifiedText) ==
-         sizeof(key_event->unmodifiedText));
-  for (size_t i = 0; i < WebKeyboardEvent::textLengthCap; ++i) {
-    pp_event->u.character.text[i] = key_event->text[i];
-    pp_event->u.character.unmodifiedText[i] = key_event->unmodifiedText[i];
+void AppendCharEvent(const WebInputEvent& event,
+                     std::vector<PP_InputEvent>* pp_events) {
+  const WebKeyboardEvent& key_event =
+      reinterpret_cast<const WebKeyboardEvent&>(event);
+
+  // This is a bit complex, the input event will normally just have one 16-bit
+  // character in it, but may be zero or more than one. The text array is
+  // just padded with 0 values for the unused ones, but is not necessarily
+  // null-terminated.
+  //
+  // Here we see how many UTF-16 characters we have.
+  size_t utf16_char_count = 0;
+  while (utf16_char_count < WebKeyboardEvent::textLengthCap &&
+         key_event.text[utf16_char_count])
+    utf16_char_count++;
+
+  // Make a separate PP_InputEvent for each Unicode character in the input.
+  base::UTF16CharIterator iter(key_event.text, utf16_char_count);
+  while (!iter.end()) {
+    PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event);
+    result.u.character.modifier = key_event.modifiers;
+
+    std::string utf8_char;
+    base::WriteUnicodeCharacter(iter.get(), &utf8_char);
+    base::strlcpy(result.u.character.text, utf8_char.c_str(),
+                  sizeof(result.u.character.text));
+
+    pp_events->push_back(result);
   }
 }
 
-void BuildMouseEvent(const WebInputEvent* event, PP_Event* pp_event) {
-  const WebMouseEvent* mouse_event =
-      reinterpret_cast<const WebMouseEvent*>(event);
-  pp_event->u.mouse.modifier = mouse_event->modifiers;
-  pp_event->u.mouse.button = mouse_event->button;
-  pp_event->u.mouse.x = static_cast<float>(mouse_event->x);
-  pp_event->u.mouse.y = static_cast<float>(mouse_event->y);
-  pp_event->u.mouse.clickCount = mouse_event->clickCount;
+void AppendMouseEvent(const WebInputEvent& event,
+                      std::vector<PP_InputEvent>* pp_events) {
+  COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonNone) ==
+                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_NONE),
+                 MouseNone);
+  COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonLeft) ==
+                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_LEFT),
+                 MouseLeft);
+  COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonRight) ==
+                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_RIGHT),
+                 MouseRight);
+  COMPILE_ASSERT(static_cast<int>(WebMouseEvent::ButtonMiddle) ==
+                 static_cast<int>(PP_INPUTEVENT_MOUSEBUTTON_MIDDLE),
+                 MouseMiddle);
+
+  const WebMouseEvent& mouse_event =
+      reinterpret_cast<const WebMouseEvent&>(event);
+  PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event);
+  result.u.mouse.modifier = mouse_event.modifiers;
+  result.u.mouse.button =
+      static_cast<PP_InputEvent_MouseButton>(mouse_event.button);
+  result.u.mouse.x = static_cast<float>(mouse_event.x);
+  result.u.mouse.y = static_cast<float>(mouse_event.y);
+  result.u.mouse.click_count = mouse_event.clickCount;
+  pp_events->push_back(result);
 }
 
-void BuildMouseWheelEvent(const WebInputEvent* event, PP_Event* pp_event) {
-  const WebMouseWheelEvent* mouse_wheel_event =
-      reinterpret_cast<const WebMouseWheelEvent*>(event);
-  pp_event->u.wheel.modifier = mouse_wheel_event->modifiers;
-  pp_event->u.wheel.deltaX = mouse_wheel_event->deltaX;
-  pp_event->u.wheel.deltaY = mouse_wheel_event->deltaY;
-  pp_event->u.wheel.wheelTicksX = mouse_wheel_event->wheelTicksX;
-  pp_event->u.wheel.wheelTicksY = mouse_wheel_event->wheelTicksY;
-  pp_event->u.wheel.scrollByPage = mouse_wheel_event->scrollByPage;
+void AppendMouseWheelEvent(const WebInputEvent& event,
+                           std::vector<PP_InputEvent>* pp_events) {
+  const WebMouseWheelEvent& mouse_wheel_event =
+      reinterpret_cast<const WebMouseWheelEvent&>(event);
+  PP_InputEvent result = GetPPEventWithCommonFieldsAndType(event);
+  result.u.wheel.modifier = mouse_wheel_event.modifiers;
+  result.u.wheel.delta_x = mouse_wheel_event.deltaX;
+  result.u.wheel.delta_y = mouse_wheel_event.deltaY;
+  result.u.wheel.wheel_ticks_x = mouse_wheel_event.wheelTicksX;
+  result.u.wheel.wheel_ticks_y = mouse_wheel_event.wheelTicksY;
+  result.u.wheel.scroll_by_page = !!mouse_wheel_event.scrollByPage;
+  pp_events->push_back(result);
 }
 
 
-WebKeyboardEvent* BuildKeyEvent(const PP_Event& event) {
+WebKeyboardEvent* BuildKeyEvent(const PP_InputEvent& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   switch (event.type) {
-    case PP_EVENT_TYPE_RAWKEYDOWN:
+    case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
       key_event->type = WebInputEvent::RawKeyDown;
       break;
-    case PP_EVENT_TYPE_KEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYDOWN:
       key_event->type = WebInputEvent::KeyDown;
       break;
-    case PP_EVENT_TYPE_KEYUP:
+    case PP_INPUTEVENT_TYPE_KEYUP:
       key_event->type = WebInputEvent::KeyUp;
       break;
+    default:
+      NOTREACHED();
   }
   key_event->timeStampSeconds = event.time_stamp_seconds;
   key_event->modifiers = event.u.key.modifier;
-  key_event->windowsKeyCode = event.u.key.normalizedKeyCode;
+  key_event->windowsKeyCode = event.u.key.key_code;
   return key_event;
 }
 
-WebKeyboardEvent* BuildCharEvent(const PP_Event& event) {
+WebKeyboardEvent* BuildCharEvent(const PP_InputEvent& event) {
   WebKeyboardEvent* key_event = new WebKeyboardEvent();
   key_event->type = WebInputEvent::Char;
   key_event->timeStampSeconds = event.time_stamp_seconds;
   key_event->modifiers = event.u.character.modifier;
-  // For consistency, check that the sizes of the texts agree.
-  DCHECK(sizeof(event.u.character.text) == sizeof(key_event->text));
-  DCHECK(sizeof(event.u.character.unmodifiedText) ==
-         sizeof(key_event->unmodifiedText));
-  for (size_t i = 0; i < WebKeyboardEvent::textLengthCap; ++i) {
-    key_event->text[i] = event.u.character.text[i];
-    key_event->unmodifiedText[i] = event.u.character.unmodifiedText[i];
-  }
+
+  // Make sure to not read beyond the buffer in case some bad code doesn't
+  // NULL-terminate it (this is called from plugins).
+  size_t text_length_cap = WebKeyboardEvent::textLengthCap;
+  size_t text_len = 0;
+  while (text_len < text_length_cap && event.u.character.text[text_len])
+      text_len++;
+  string16 text16 = UTF8ToUTF16(std::string(event.u.character.text, text_len));
+
+  memset(key_event->text, 0, text_length_cap);
+  memset(key_event->unmodifiedText, 0, text_length_cap);
+  for (size_t i = 0;
+       i < std::min(text_length_cap, text16.size());
+       ++i)
+    key_event->text[i] = text16[i];
   return key_event;
 }
 
-WebMouseEvent* BuildMouseEvent(const PP_Event& event) {
+WebMouseEvent* BuildMouseEvent(const PP_InputEvent& event) {
   WebMouseEvent* mouse_event = new WebMouseEvent();
   switch (event.type) {
-    case PP_EVENT_TYPE_MOUSEDOWN:
+    case PP_INPUTEVENT_TYPE_MOUSEDOWN:
       mouse_event->type = WebInputEvent::MouseDown;
       break;
-    case PP_EVENT_TYPE_MOUSEUP:
+    case PP_INPUTEVENT_TYPE_MOUSEUP:
       mouse_event->type = WebInputEvent::MouseUp;
       break;
-    case PP_EVENT_TYPE_MOUSEMOVE:
+    case PP_INPUTEVENT_TYPE_MOUSEMOVE:
       mouse_event->type = WebInputEvent::MouseMove;
       break;
-    case PP_EVENT_TYPE_MOUSEENTER:
+    case PP_INPUTEVENT_TYPE_MOUSEENTER:
       mouse_event->type = WebInputEvent::MouseEnter;
       break;
-    case PP_EVENT_TYPE_MOUSELEAVE:
+    case PP_INPUTEVENT_TYPE_MOUSELEAVE:
       mouse_event->type = WebInputEvent::MouseLeave;
       break;
+    default:
+      NOTREACHED();
   }
   mouse_event->timeStampSeconds = event.time_stamp_seconds;
   mouse_event->modifiers = event.u.mouse.modifier;
@@ -148,20 +214,20 @@ WebMouseEvent* BuildMouseEvent(const PP_Event& event) {
       static_cast<WebMouseEvent::Button>(event.u.mouse.button);
   mouse_event->x = static_cast<int>(event.u.mouse.x);
   mouse_event->y = static_cast<int>(event.u.mouse.y);
-  mouse_event->clickCount = event.u.mouse.clickCount;
+  mouse_event->clickCount = event.u.mouse.click_count;
   return mouse_event;
 }
 
-WebMouseWheelEvent* BuildMouseWheelEvent(const PP_Event& event) {
+WebMouseWheelEvent* BuildMouseWheelEvent(const PP_InputEvent& event) {
   WebMouseWheelEvent* mouse_wheel_event = new WebMouseWheelEvent();
   mouse_wheel_event->type = WebInputEvent::MouseWheel;
   mouse_wheel_event->timeStampSeconds = event.time_stamp_seconds;
   mouse_wheel_event->modifiers = event.u.wheel.modifier;
-  mouse_wheel_event->deltaX = event.u.wheel.deltaX;
-  mouse_wheel_event->deltaY = event.u.wheel.deltaY;
-  mouse_wheel_event->wheelTicksX = event.u.wheel.wheelTicksX;
-  mouse_wheel_event->wheelTicksY = event.u.wheel.wheelTicksY;
-  mouse_wheel_event->scrollByPage = event.u.wheel.scrollByPage;
+  mouse_wheel_event->deltaX = event.u.wheel.delta_x;
+  mouse_wheel_event->deltaY = event.u.wheel.delta_y;
+  mouse_wheel_event->wheelTicksX = event.u.wheel.wheel_ticks_x;
+  mouse_wheel_event->wheelTicksY = event.u.wheel.wheel_ticks_y;
+  mouse_wheel_event->scrollByPage = event.u.wheel.scroll_by_page;
   return mouse_wheel_event;
 }
 
@@ -169,64 +235,58 @@ WebMouseWheelEvent* BuildMouseWheelEvent(const PP_Event& event) {
 
 namespace pepper {
 
-PP_Event* CreatePP_Event(const WebInputEvent& event) {
-  scoped_ptr<PP_Event> pp_event(new PP_Event);
+void CreatePPEvent(const WebInputEvent& event,
+                   std::vector<PP_InputEvent>* pp_events) {
+  pp_events->clear();
 
-  pp_event->type = ConvertEventTypes(event.type);
-  pp_event->size = sizeof(pp_event);
-  pp_event->time_stamp_seconds = event.timeStampSeconds;
-  switch (pp_event->type) {
-    case PP_EVENT_TYPE_UNDEFINED:
-      return NULL;
-    case PP_EVENT_TYPE_MOUSEDOWN:
-    case PP_EVENT_TYPE_MOUSEUP:
-    case PP_EVENT_TYPE_MOUSEMOVE:
-    case PP_EVENT_TYPE_MOUSEENTER:
-    case PP_EVENT_TYPE_MOUSELEAVE:
-      BuildMouseEvent(&event, pp_event.get());
+  switch (event.type) {
+    case WebInputEvent::MouseDown:
+    case WebInputEvent::MouseUp:
+    case WebInputEvent::MouseMove:
+    case WebInputEvent::MouseEnter:
+    case WebInputEvent::MouseLeave:
+      AppendMouseEvent(event, pp_events);
       break;
-    case PP_EVENT_TYPE_MOUSEWHEEL:
-      BuildMouseWheelEvent(&event, pp_event.get());
+    case WebInputEvent::MouseWheel:
+      AppendMouseWheelEvent(event, pp_events);
       break;
-    case PP_EVENT_TYPE_RAWKEYDOWN:
-    case PP_EVENT_TYPE_KEYDOWN:
-    case PP_EVENT_TYPE_KEYUP:
-      BuildKeyEvent(&event, pp_event.get());
+    case WebInputEvent::RawKeyDown:
+    case WebInputEvent::KeyDown:
+    case WebInputEvent::KeyUp:
+      AppendKeyEvent(event, pp_events);
       break;
-    case PP_EVENT_TYPE_CHAR:
-      BuildCharEvent(&event, pp_event.get());
+    case WebInputEvent::Char:
+      AppendCharEvent(event, pp_events);
+      break;
+    case WebInputEvent::Undefined:
+    default:
       break;
   }
-
-  return pp_event.release();
 }
 
-WebInputEvent* CreateWebInputEvent(const PP_Event& event) {
+WebInputEvent* CreateWebInputEvent(const PP_InputEvent& event) {
   scoped_ptr<WebInputEvent> web_input_event;
   switch (event.type) {
-    case PP_EVENT_TYPE_UNDEFINED:
+    case PP_INPUTEVENT_TYPE_UNDEFINED:
       return NULL;
-    case PP_EVENT_TYPE_MOUSEDOWN:
-    case PP_EVENT_TYPE_MOUSEUP:
-    case PP_EVENT_TYPE_MOUSEMOVE:
-    case PP_EVENT_TYPE_MOUSEENTER:
-    case PP_EVENT_TYPE_MOUSELEAVE:
+    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_input_event.reset(BuildMouseEvent(event));
       break;
-    case PP_EVENT_TYPE_MOUSEWHEEL:
+    case PP_INPUTEVENT_TYPE_MOUSEWHEEL:
       web_input_event.reset(BuildMouseWheelEvent(event));
       break;
-    case PP_EVENT_TYPE_RAWKEYDOWN:
-    case PP_EVENT_TYPE_KEYDOWN:
-    case PP_EVENT_TYPE_KEYUP:
+    case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYDOWN:
+    case PP_INPUTEVENT_TYPE_KEYUP:
       web_input_event.reset(BuildKeyEvent(event));
       break;
-    case PP_EVENT_TYPE_CHAR:
+    case PP_INPUTEVENT_TYPE_CHAR:
       web_input_event.reset(BuildCharEvent(event));
       break;
-    case PP_EVENT_TYPE_FOCUS:
-      // NOTIMPLEMENTED();
-      return NULL;
   }
 
   return web_input_event.release();
diff --git a/webkit/glue/plugins/pepper_event_conversion.h b/webkit/glue/plugins/pepper_event_conversion.h
index 3f3fa68..9eab3e4 100644
--- a/webkit/glue/plugins/pepper_event_conversion.h
+++ b/webkit/glue/plugins/pepper_event_conversion.h
@@ -5,7 +5,9 @@
 #ifndef WEBKIT_GLUE_PLUGINS_PEPPER_EVENT_H_
 #define WEBKIT_GLUE_PLUGINS_PEPPER_EVENT_H_
 
-struct PP_Event;
+#include <vector>
+
+struct PP_InputEvent;
 
 namespace WebKit {
 class WebInputEvent;
@@ -13,13 +15,15 @@ class WebInputEvent;
 
 namespace pepper {
 
-// Creates a PP_Event from the given WebInputEvent.  If it fails, returns NULL.
-// The caller owns the created object on success.
-PP_Event* CreatePP_Event(const WebKit::WebInputEvent& event);
+// Converts the given WebKit event to one or possibly multiple PP_InputEvents.
+// The generated events will be filled into the given vector. On failure, no
+// events will ge generated and the vector will be empty.
+void CreatePPEvent(const WebKit::WebInputEvent& event,
+                   std::vector<PP_InputEvent>* pp_events);
 
-// Creates a WebInputEvent from the given PP_Event.  If it fails, returns NULL.
-// The caller owns the created object on success.
-WebKit::WebInputEvent* CreateWebInputEvent(const PP_Event& event);
+// Creates a WebInputEvent from the given PP_InputEvent.  If it fails, returns
+// NULL.  The caller owns the created object on success.
+WebKit::WebInputEvent* CreateWebInputEvent(const PP_InputEvent& event);
 
 }  // namespace pepper
 
diff --git a/webkit/glue/plugins/pepper_plugin_instance.cc b/webkit/glue/plugins/pepper_plugin_instance.cc
index 1a1290e..b246872 100644
--- a/webkit/glue/plugins/pepper_plugin_instance.cc
+++ b/webkit/glue/plugins/pepper_plugin_instance.cc
@@ -26,7 +26,7 @@
 #include "third_party/ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "third_party/ppapi/c/dev/ppp_find_dev.h"
 #include "third_party/ppapi/c/dev/ppp_zoom_dev.h"
-#include "third_party/ppapi/c/pp_event.h"
+#include "third_party/ppapi/c/pp_input_event.h"
 #include "third_party/ppapi/c/pp_instance.h"
 #include "third_party/ppapi/c/pp_rect.h"
 #include "third_party/ppapi/c/pp_resource.h"
@@ -450,16 +450,23 @@ bool PluginInstance::HandleDocumentLoad(URLLoader* loader) {
 
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
-  scoped_ptr<PP_Event> pp_event(CreatePP_Event(event));
-  if (!pp_event.get())
-    return false;
+  std::vector<PP_InputEvent> pp_events;
+  CreatePPEvent(event, &pp_events);
+
+  // Each input event may generate more than one PP_InputEvent.
+  bool rv = false;
+  for (size_t i = 0; i < pp_events.size(); i++)
+    rv |= instance_interface_->HandleInputEvent(GetPPInstance(), &pp_events[i]);
 
-  bool rv = instance_interface_->HandleEvent(GetPPInstance(), pp_event.get());
   if (cursor_.get())
     *cursor_info = *cursor_;
   return rv;
 }
 
+void PluginInstance::FocusChanged(bool has_focus) {
+  instance_interface_->FocusChanged(GetPPInstance(), has_focus);
+}
+
 PP_Var PluginInstance::GetInstanceObject() {
   return instance_interface_->GetInstanceObject(GetPPInstance());
 }
diff --git a/webkit/glue/plugins/pepper_plugin_instance.h b/webkit/glue/plugins/pepper_plugin_instance.h
index bf8f027..0ed6ee6 100644
--- a/webkit/glue/plugins/pepper_plugin_instance.h
+++ b/webkit/glue/plugins/pepper_plugin_instance.h
@@ -107,6 +107,7 @@ class PluginInstance : public base::RefCounted<PluginInstance> {
   bool HandleDocumentLoad(URLLoader* loader);
   bool HandleInputEvent(const WebKit::WebInputEvent& event,
                         WebKit::WebCursorInfo* cursor_info);
+  void FocusChanged(bool has_focus);
   PP_Var GetInstanceObject();
   void ViewChanged(const gfx::Rect& position, const gfx::Rect& clip);
 
diff --git a/webkit/glue/plugins/pepper_scrollbar.cc b/webkit/glue/plugins/pepper_scrollbar.cc
index c704112..a8943d2 100644
--- a/webkit/glue/plugins/pepper_scrollbar.cc
+++ b/webkit/glue/plugins/pepper_scrollbar.cc
@@ -173,7 +173,7 @@ bool Scrollbar::Paint(const PP_Rect* rect, ImageData* image) {
   return true;
 }
 
-bool Scrollbar::HandleEvent(const PP_Event* event) {
+bool Scrollbar::HandleEvent(const PP_InputEvent* event) {
   scoped_ptr<WebInputEvent> web_input_event(CreateWebInputEvent(*event));
   if (!web_input_event.get())
     return false;
diff --git a/webkit/glue/plugins/pepper_scrollbar.h b/webkit/glue/plugins/pepper_scrollbar.h
index 4b1e478..e8ac480 100644
--- a/webkit/glue/plugins/pepper_scrollbar.h
+++ b/webkit/glue/plugins/pepper_scrollbar.h
@@ -38,7 +38,7 @@ class Scrollbar : public Widget, public WebKit::WebScrollbarClient {
 
   // PPB_Widget implementation.
   virtual bool Paint(const PP_Rect* rect, ImageData* image);
-  virtual bool HandleEvent(const PP_Event* event);
+  virtual bool HandleEvent(const PP_InputEvent* event);
   virtual void SetLocationInternal(const PP_Rect* location);
 
  private:
diff --git a/webkit/glue/plugins/pepper_webplugin_impl.cc b/webkit/glue/plugins/pepper_webplugin_impl.cc
index b7fc7b4..e92efac 100644
--- a/webkit/glue/plugins/pepper_webplugin_impl.cc
+++ b/webkit/glue/plugins/pepper_webplugin_impl.cc
@@ -96,6 +96,7 @@ void WebPluginImpl::updateGeometry(
 }
 
 void WebPluginImpl::updateFocus(bool focused) {
+  instance_->FocusChanged(focused);
 }
 
 void WebPluginImpl::updateVisibility(bool visible) {
diff --git a/webkit/glue/plugins/pepper_widget.cc b/webkit/glue/plugins/pepper_widget.cc
index af1bb59..1ba5280 100644
--- a/webkit/glue/plugins/pepper_widget.cc
+++ b/webkit/glue/plugins/pepper_widget.cc
@@ -33,7 +33,7 @@ bool Paint(PP_Resource resource, const PP_Rect* rect, PP_Resource image_id) {
   return widget->Paint(rect, image);
 }
 
-bool HandleEvent(PP_Resource resource, const PP_Event* event) {
+bool HandleEvent(PP_Resource resource, const PP_InputEvent* event) {
   scoped_refptr<Widget> widget(Resource::GetAs<Widget>(resource));
   return widget && widget->HandleEvent(event);
 }
diff --git a/webkit/glue/plugins/pepper_widget.h b/webkit/glue/plugins/pepper_widget.h
index e2726e2..47826e3 100644
--- a/webkit/glue/plugins/pepper_widget.h
+++ b/webkit/glue/plugins/pepper_widget.h
@@ -10,7 +10,7 @@
 #include "webkit/glue/plugins/pepper_resource.h"
 
 struct PPB_Widget_Dev;
-struct PP_Event;
+struct PP_InputEvent;
 
 namespace pepper {
 
@@ -31,7 +31,7 @@ class Widget : public Resource  {
 
   // PPB_Widget implementation.
   virtual bool Paint(const PP_Rect* rect, ImageData* image) = 0;
-  virtual bool HandleEvent(const PP_Event* event) = 0;
+  virtual bool HandleEvent(const PP_InputEvent* event) = 0;
   bool GetLocation(PP_Rect* location);
   void SetLocation(const PP_Rect* location);