Implement an input event resource.

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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
+#include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "printing/units.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
@@ skipping 12 matching lines @@
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/event_conversion.h"
 #include "webkit/plugins/ppapi/fullscreen_container.h"
 #include "webkit/plugins/ppapi/message_channel.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
+#include "webkit/plugins/ppapi/ppb_input_event_impl.h"
 #include "webkit/plugins/ppapi/ppb_surface_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_request_info_impl.h"
 #include "webkit/plugins/ppapi/ppp_pdf.h"
 #include "webkit/plugins/ppapi/string.h"
 #include "webkit/plugins/ppapi/var.h"
 #include "webkit/plugins/sad_plugin.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
@@ skipping 201 matching lines @@
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_messaging_interface_(NULL),
+      plugin_input_event_interface_(NULL),
+      plugin_private_interface_(NULL),
       plugin_pdf_interface_(NULL),
-      plugin_private_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_zoom_interface_(NULL),
+      checked_for_plugin_input_event_interface_(false),
       checked_for_plugin_messaging_interface_(false),
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL),
       fullscreen_(false),
       message_channel_(NULL),
-      sad_plugin_(NULL) {
+      sad_plugin_(NULL),
+      input_event_mask_(0),
+      filtered_input_event_mask_(0) {
   pp_instance_ = ResourceTracker::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   DCHECK(delegate);
   module_->InstanceCreated(this);
   delegate_->InstanceCreated(this);
   message_channel_.reset(new MessageChannel(this));
 }
 
 PluginInstance::~PluginInstance() {
@@ skipping 196 matching lines @@
 bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
   Resource::ScopedResourceId resource(loader);
   return PPBoolToBool(instance_interface_->HandleDocumentLoad(pp_instance(),
                                                               resource.id));
 }
 
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
+
+  bool rv = false;
+  if (LoadInputEventInterface()) {
+    PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
+    if (!event_class)
+      return false;
+
+    if ((filtered_input_event_mask_ & event_class) ||
+        (input_event_mask_ & event_class)) {
+      // Actually send the event.
+      std::vector< ::ppapi::InputEventData > events;
+      CreateInputEventData(event, &events);
+
+      // Each input event may generate more than one PP_InputEvent.
+      ResourceTracker* tracker = ResourceTracker::Get();
+      for (size_t i = 0; i < events.size(); i++) {
+        if (filtered_input_event_mask_ & event_class)
+          events[i].is_filtered = true;
+        scoped_refptr<PPB_InputEvent_Impl> event_resource(
+            new PPB_InputEvent_Impl(this, events[i]));
+        PP_Resource resource = event_resource->GetReference();
+
+        rv |= PPBoolToBool(plugin_input_event_interface_->HandleInputEvent(
+            pp_instance(), event_resource->GetReference()));
+
+        // Release the reference we took above.
+        tracker->UnrefResource(resource);
+      }
+    }
+  }
+
+  // For compatibility, also send all input events through the old interface.
+  // TODO(brettw) remove this.
   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 |= PPBoolToBool(instance_interface_->HandleInputEvent(pp_instance(),
                                                              &pp_events[i]));
   }
 
   if (cursor_.get())
     *cursor_info = *cursor_;
   return rv;
 }
 
@@ skipping 186 matching lines @@
 bool PluginInstance::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
         static_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
             PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
+bool PluginInstance::LoadInputEventInterface() {
+  if (!checked_for_plugin_input_event_interface_) {
+    checked_for_plugin_input_event_interface_ = true;
+    plugin_input_event_interface_ =
+        static_cast<const PPP_InputEvent*>(module_->GetPluginInterface(
+            PPP_INPUT_EVENT_INTERFACE));
+  }
+  return !!plugin_input_event_interface_;
+}
+
 bool PluginInstance::LoadMessagingInterface() {
   if (!checked_for_plugin_messaging_interface_) {
     checked_for_plugin_messaging_interface_ = true;
     plugin_messaging_interface_ =
         static_cast<const PPP_Messaging*>(module_->GetPluginInterface(
             PPP_MESSAGING_INTERFACE));
   }
 
   return !!plugin_messaging_interface_;
 }
@@ skipping 773 matching lines @@
   return PP_FALSE;
 #endif
 }
 
 PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
   gfx::Size screen_size = delegate()->GetScreenSize();
   *size = PP_MakeSize(screen_size.width(), screen_size.height());
   return PP_TRUE;
 }
 
+int32_t PluginInstance::RequestInputEvents(PP_Instance instance,
+                                           uint32_t event_classes) {
+  // Don't allow unfiltered keyboard access. The error return value will be
+  // generated by ValidateRequestInputEvents.
+  uint32_t fixed_classes =
+      event_classes & ~uint32_t(PP_INPUTEVENT_CLASS_KEYBOARD);
+
+  input_event_mask_ |= fixed_classes;
+  filtered_input_event_mask_ &= ~(fixed_classes);
+
+  // Validate based on the original input to catch errors.
+  return ValidateRequestInputEvents(false, event_classes);
+}
+
+int32_t PluginInstance::RequestFilteringInputEvents(PP_Instance instance,
+                                                    uint32_t event_classes) {
+  filtered_input_event_mask_ |= event_classes;
+  input_event_mask_ &= ~(event_classes);
+  return ValidateRequestInputEvents(true, event_classes);
+}
+
+void PluginInstance::ClearInputEventRequest(PP_Instance instance,
+                                            uint32_t event_classes) {
+  input_event_mask_ &= ~(event_classes);
+  filtered_input_event_mask_ &= ~(event_classes);
+}
+
 }  // namespace ppapi
 }  // namespace webkit