Import GTK WebInputEvent factory to content

content/browser/renderer_host/render_widget_host_view_gtk.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_gtk.h"
 
 #include <cairo/cairo.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
@@ skipping 11 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/accessibility/browser_accessibility_gtk.h"
 #include "content/browser/accessibility/browser_accessibility_manager_gtk.h"
 #include "content/browser/renderer_host/backing_store_gtk.h"
 #include "content/browser/renderer_host/gtk_im_context_wrapper.h"
 #include "content/browser/renderer_host/gtk_key_bindings_handler.h"
 #include "content/browser/renderer_host/gtk_window_utils.h"
+#include "content/browser/renderer_host/input/web_input_event_builders_gtk.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/webplugin_geometry.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/common/content_switches.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
-#include "third_party/WebKit/public/web/gtk/WebInputEventFactory.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
 #include "webkit/common/cursors/webcursor_gtk_data.h"
 
-using WebKit::WebInputEventFactory;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebScreenInfo;
 
 namespace content {
 namespace {
 
 // Paint rects on Linux are bounded by the maximum size of a shared memory
 // region. By default that's 32MB, but many distros increase it significantly
 // (i.e. to 256MB).
 //
 // We fetch the maximum value from /proc/sys/kernel/shmmax at runtime and, if
 // we exceed that, then we limit the height of the paint rect in the renderer.
 //
 // These constants are here to ensure that, in the event that we exceed it, we
 // end up with something a little more square. Previously we had 4000x4000, but
 // people's monitor setups are actually exceeding that these days.
 const int kMaxWindowWidth = 10000;
 const int kMaxWindowHeight = 10000;
 
-// See WebInputEventFactor.cpp for a reason for this being the default
+// See WebInputEventFactory.cpp for a reason for this being the default
 // scroll size for linux.
 const float kDefaultScrollPixelsPerTick = 160.0f / 3.0f;

[jdduke (slow), 2013/09/16 15:31:55]

Could we store this constant in a single location? Perhaps a static method on
WebMouseWheelEventBuilder?

[garykac, 2013/09/16 22:45:05]

WebMouseWheelEventBuilder seems like a reasonable place, but it's in Blink, so
it would need to be a separate cl.
Bug filed to track: crbug.com/292920

[jdduke (slow), 2013/09/16 23:46:58]

I see, I was thinking more so of the use here, and in WebMouseWheelEventBuilder
(web_input_event_builders_gtk.cpp:579, static const float scrollbarPixelsPerTick
= 160.0f / 3.0f;).  As both lines fall in this patch, could we consolidate just
the two for now, and leave the Blink/remoting duplications for another day?

 
 const GdkColor kBGColor =
 #if defined(NDEBUG)
     { 0, 0xff * 257, 0xff * 257, 0xff * 257 };
 #else
     { 0, 0x00 * 257, 0xff * 257, 0x00 * 257 };
 #endif
 
 // Returns the spinning cursor used for loading state.
 GdkCursor* GetMozSpinningCursor() {
@@ skipping 261 matching lines @@
 
     // TODO(evanm): why is this necessary here but not in test shell?
     // This logic is the same as GtkButton.
     if (event->type == GDK_BUTTON_PRESS && !gtk_widget_has_focus(widget))
       gtk_widget_grab_focus(widget);
 
     host_view->is_popup_first_mouse_release_ = false;
     RenderWidgetHostImpl* widget_host =
         RenderWidgetHostImpl::From(host_view->GetRenderWidgetHost());
     if (widget_host)
-      widget_host->ForwardMouseEvent(WebInputEventFactory::mouseEvent(event));
+      widget_host->ForwardMouseEvent(WebMouseEventBuilder::Build(event));
 
     // Although we did handle the mouse event, we need to let other handlers
     // run (in particular the one installed by WebContentsViewGtk).
     return FALSE;
   }
 
   static gboolean OnMouseMoveEvent(GtkWidget* widget,
                                    GdkEventMotion* event,
                                    RenderWidgetHostViewGtk* host_view) {
     TRACE_EVENT0("browser",
                  "RenderWidgetHostViewGtkWidget::OnMouseMoveEvent");
     // We want to translate the coordinates of events that do not originate
     // from this widget to be relative to the top left of the widget.
     GtkWidget* event_widget = gtk_get_event_widget(
         reinterpret_cast<GdkEvent*>(event));
     if (event_widget != widget) {
       int x = 0;
       int y = 0;
       gtk_widget_get_pointer(widget, &x, &y);
       event->x = x;
       event->y = y;
     }
 
     host_view->ModifyEventForEdgeDragging(widget, event);
 
-    WebKit::WebMouseEvent mouse_event =
-        WebInputEventFactory::mouseEvent(event);
+    WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
 
     if (host_view->mouse_locked_) {
       gfx::Point center = host_view->GetWidgetCenter();
 
       bool moved_to_center = MovedToPoint(mouse_event, center);
       if (moved_to_center)
         host_view->mouse_has_been_warped_to_new_center_ = true;
 
       host_view->ModifyEventMovementAndCoords(&mouse_event);
 
@@ skipping 29 matching lines @@
         GDK_BUTTON3_MASK |
         GDK_BUTTON4_MASK |
         GDK_BUTTON5_MASK;
 
     // Only forward crossing events if the mouse button is not down.
     // (When the mouse button is down, the proper events are already being
     // sent by ButtonPressReleaseEvent and MouseMoveEvent, above, and if we
     // additionally send this crossing event with the state indicating the
     // button is down, it causes problems with drag and drop in WebKit.)
     if (!(event->state & any_button_mask)) {
-      WebKit::WebMouseEvent mouse_event =
-          WebInputEventFactory::mouseEvent(event);
+      WebKit::WebMouseEvent mouse_event = WebMouseEventBuilder::Build(event);
       host_view->ModifyEventMovementAndCoords(&mouse_event);
       // When crossing out and back into a render view the movement values
       // must represent the instantaneous movement of the mouse, not the jump
       // from the exit to re-entry point.
       mouse_event.movementX = 0;
       mouse_event.movementY = 0;
       RenderWidgetHostImpl::From(
           host_view->GetRenderWidgetHost())->ForwardMouseEvent(mouse_event);
     }
 
@@ skipping 65 matching lines @@
     // If the user is holding shift, translate it into a horizontal scroll. We
     // don't care what other modifiers the user may be holding (zooming is
     // handled at the WebContentsView level).
     if (event->state & GDK_SHIFT_MASK) {
       if (event->direction == GDK_SCROLL_UP)
         event->direction = GDK_SCROLL_LEFT;
       else if (event->direction == GDK_SCROLL_DOWN)
         event->direction = GDK_SCROLL_RIGHT;
     }
 
-    WebMouseWheelEvent web_event = WebInputEventFactory::mouseWheelEvent(event);
+    WebMouseWheelEvent web_event = WebMouseWheelEventBuilder::Build(event);
     // We  peek ahead at the top of the queue to look for additional pending
     // scroll events.
     if (event->direction == GDK_SCROLL_UP ||
         event->direction == GDK_SCROLL_DOWN) {
       if (event->direction == GDK_SCROLL_UP)
         web_event.deltaY = kDefaultScrollPixelsPerTick;
       else
         web_event.deltaY = -kDefaultScrollPixelsPerTick;
       web_event.deltaY += GetPendingScrollDelta(true, event->state);
     } else {
@@ skipping 1045 matching lines @@
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::OnDestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
 }
 
 }  // namespace content