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/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_compat.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/gtk_preserve_window.h"
 #include "ui/gfx/text_elider.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
-// scroll size for linux.
-const float kDefaultScrollPixelsPerTick = 160.0f / 3.0f;
-
 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() {
   static GdkCursor* moz_spinning_cursor = NULL;
@@ skipping 260 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 47 matching lines @@
             }
           }
         }
       }
     }
     // If we have an event left we put it back on the queue.
     if (event) {
       gdk_event_put(event);
       gdk_event_free(event);
     }
-    return num_clicks * kDefaultScrollPixelsPerTick;
+    return num_clicks * WebMouseWheelEventBuilder::ScrollbarPixelsPerTick();
   }
 
   static gboolean OnMouseScrollEvent(GtkWidget* widget,
                                      GdkEventScroll* event,
                                      RenderWidgetHostViewGtk* host_view) {
     TRACE_EVENT0("browser",
                  "RenderWidgetHostViewGtkWidget::OnMouseScrollEvent");
     // 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);
+    const float pixelsPerTick =
+        WebMouseWheelEventBuilder::ScrollbarPixelsPerTick();
     // 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;
+        web_event.deltaY = pixelsPerTick;
       else
-        web_event.deltaY = -kDefaultScrollPixelsPerTick;
+        web_event.deltaY = -pixelsPerTick;
       web_event.deltaY += GetPendingScrollDelta(true, event->state);
     } else {
       if (event->direction == GDK_SCROLL_LEFT)
-        web_event.deltaX = kDefaultScrollPixelsPerTick;
+        web_event.deltaX = pixelsPerTick;
       else
-        web_event.deltaX = -kDefaultScrollPixelsPerTick;
+        web_event.deltaX = -pixelsPerTick;
       web_event.deltaX += GetPendingScrollDelta(false, event->state);
     }
     RenderWidgetHostImpl::From(
         host_view->GetRenderWidgetHost())->ForwardWheelEvent(web_event);
     return FALSE;
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RenderWidgetHostViewGtkWidget);
 };
 
@@ skipping 1031 matching lines @@
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.CreatePluginContainer(id);
 }
 
 void RenderWidgetHostViewGtk::OnDestroyPluginContainer(
     gfx::PluginWindowHandle id) {
   plugin_container_manager_.DestroyPluginContainer(id);
 }
 
 }  // namespace content