Update LocatedEvent and MouseWheelEvent.

Refactor RootView::OnMouseWheel and WidgetGtk::ProcessScroll.
Rename RootView's and MenuHostRootView's ProcessMouseWheelEvent to OnMouseWheel.
Merge event_x's GetMouseEventType into EventTypeFromNative and detect wheel events.
Update NativeWidgetWin::MakeMSG and WidgetWin::MakeMSG.
Add some needed support functions.

BUG=72040
TEST=none

Review URL: http://codereview.chromium.org/6469106

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

15 files changed, 261 insertions, 151 deletions

diff --git a/ui/views/widget/native_widget_win.cc b/ui/views/widget/native_widget_win.cc
index 250ae2f..bc89810 100644
--- a/ui/views/widget/native_widget_win.cc
+++ b/ui/views/widget/native_widget_win.cc
@@ -613,13 +613,14 @@ bool NativeWidgetWin::ProcessMouseRange(UINT message, WPARAM w_param,
 }
 
 void NativeWidgetWin::MakeMSG(MSG* msg, UINT message, WPARAM w_param,
-                              LPARAM l_param) const {
+    LPARAM l_param, DWORD time, LONG x, LONG y) const {
   msg->hwnd = hwnd();
   msg->message = message;
   msg->wParam = w_param;
   msg->lParam = l_param;
-  msg->time = 0;
-  msg->pt.x = msg->pt.y = 0;
+  msg->time = time;
+  msg->pt.x = x;
+  msg->pt.y = y;
 }
 
 void NativeWidgetWin::CloseNow() {
diff --git a/ui/views/widget/native_widget_win.h b/ui/views/widget/native_widget_win.h
index f5c8eec..c3e724e 100644
--- a/ui/views/widget/native_widget_win.h
+++ b/ui/views/widget/native_widget_win.h
@@ -238,7 +238,8 @@ class NativeWidgetWin : public NativeWidget,
   void ProcessMouseExited();
 
   // Fills out a MSG struct with the supplied values.
-  void MakeMSG(MSG* msg, UINT message, WPARAM w_param, LPARAM l_param) const;
+  void MakeMSG(MSG* msg, UINT message, WPARAM w_param, LPARAM l_param,
+               DWORD time = 0, LONG x = 0, LONG y = 0) const;
 
   void CloseNow();
 
diff --git a/views/controls/menu/menu_host_root_view.cc b/views/controls/menu/menu_host_root_view.cc
index 0b2a971..cc0124c 100644
--- a/views/controls/menu/menu_host_root_view.cc
+++ b/views/controls/menu/menu_host_root_view.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -66,6 +66,12 @@ void MenuHostRootView::OnMouseMoved(const MouseEvent& event) {
     GetMenuController()->OnMouseMoved(submenu_, event);
 }
 
+bool MenuHostRootView::OnMouseWheel(const MouseWheelEvent& e) {
+  // RootView::OnMouseWheel forwards to the focused view. We don't have a
+  // focused view, so we need to override this then forward to the menu.
+  return submenu_->OnMouseWheel(e);
+}
+
 void MenuHostRootView::ProcessOnMouseExited() {
   if (suspend_events_)
     return;
@@ -73,13 +79,6 @@ void MenuHostRootView::ProcessOnMouseExited() {
   RootView::ProcessOnMouseExited();
 }
 
-bool MenuHostRootView::ProcessMouseWheelEvent(const MouseWheelEvent& e) {
-  // RootView::ProcessMouseWheelEvent forwards to the focused view. We don't
-  // have a focused view, so we need to override this then forward to
-  // the menu.
-  return submenu_->OnMouseWheel(e);
-}
-
 MenuController* MenuHostRootView::GetMenuController() {
   return submenu_->GetMenuItem()->GetMenuController();
 }
diff --git a/views/controls/menu/menu_host_root_view.h b/views/controls/menu/menu_host_root_view.h
index d42804f..c2b06f1 100644
--- a/views/controls/menu/menu_host_root_view.h
+++ b/views/controls/menu/menu_host_root_view.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -32,8 +32,8 @@ class MenuHostRootView : public RootView {
   virtual bool OnMouseDragged(const MouseEvent& event);
   virtual void OnMouseReleased(const MouseEvent& event, bool canceled);
   virtual void OnMouseMoved(const MouseEvent& event);
+  virtual bool OnMouseWheel(const MouseWheelEvent& e);
   virtual void ProcessOnMouseExited();
-  virtual bool ProcessMouseWheelEvent(const MouseWheelEvent& e);
 
  private:
   // Returns the MenuController for this MenuHostRootView.
diff --git a/views/events/event.cc b/views/events/event.cc
index 49fe29b..f51ec0a 100644
--- a/views/events/event.cc
+++ b/views/events/event.cc
@@ -36,13 +36,20 @@ Event::Event(NativeEvent2 native_event_2, ui::EventType type, int flags,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// LocatedEvent, public:
+// LocatedEvent, protected:
 
-LocatedEvent::LocatedEvent(const LocatedEvent& model, View* from, View* to)
+LocatedEvent::LocatedEvent(ui::EventType type, const gfx::Point& location,
+                           int flags)
+    : Event(type, flags),
+      location_(location) {
+}
+
+LocatedEvent::LocatedEvent(const LocatedEvent& model, View* source,
+                           View* target)
     : Event(model),
       location_(model.location_) {
-  if (to)
-    View::ConvertPointToView(from, to, &location_);
+  if (target)
+    View::ConvertPointToView(source, target, &location_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -71,10 +78,8 @@ MouseEvent::MouseEvent(ui::EventType type,
                        View* to,
                        const gfx::Point &l,
                        int flags)
-    : LocatedEvent(LocatedEvent(type, gfx::Point(l.x(), l.y()), flags),
-                                from,
-                                to) {
-};
+    : LocatedEvent(MouseEvent(type, l.x(), l.y(), flags), from, to) {
+}
 
 MouseEvent::MouseEvent(const MouseEvent& model, View* from, View* to)
     : LocatedEvent(model, from, to) {
@@ -84,7 +89,8 @@ MouseEvent::MouseEvent(const MouseEvent& model, View* from, View* to)
 // TouchEvent, public:
 
 #if defined(TOUCH_UI)
-TouchEvent::TouchEvent(ui::EventType type, int x, int y, int flags, int touch_id)
+TouchEvent::TouchEvent(ui::EventType type, int x, int y, int flags,
+                       int touch_id)
       : LocatedEvent(type, gfx::Point(x, y), flags),
         touch_id_(touch_id) {
 }
@@ -96,9 +102,7 @@ TouchEvent::TouchEvent(ui::EventType type,
                        const gfx::Point& l,
                        int flags,
                        int touch_id)
-    : LocatedEvent(LocatedEvent(type, gfx::Point(l.x(), l.y()), flags),
-                                from,
-                                to),
+    : LocatedEvent(TouchEvent(type, l.x(), l.y(), flags, touch_id), from, to),
       touch_id_(touch_id) {
 }
 
diff --git a/views/events/event.h b/views/events/event.h
index 83f8bbf..426862e 100644
--- a/views/events/event.h
+++ b/views/events/event.h
@@ -88,7 +88,7 @@ class Event {
   static int ConvertWindowsFlags(uint32 win_flags);
 #elif defined(OS_LINUX)
   // Convert the state member on a GdkEvent to views::Event flags
-  static int GetFlagsFromGdkState(int state);
+  static int GetFlagsFromGdkState(unsigned int state);
 #endif
 
  protected:
@@ -132,16 +132,6 @@ class Event {
 ////////////////////////////////////////////////////////////////////////////////
 class LocatedEvent : public Event {
  public:
-  LocatedEvent(ui::EventType type, const gfx::Point& location, int flags)
-      : Event(type, flags),
-        location_(location) {
-  }
-
-  // Create a new LocatedEvent which is identical to the provided model.
-  // If from / to views are provided, the model location will be converted
-  // from 'from' coordinate system to 'to' coordinate system
-  LocatedEvent(const LocatedEvent& model, View* from, View* to);
-
   int x() const { return location_.x(); }
   int y() const { return location_.y(); }
   const gfx::Point& location() const { return location_; }
@@ -151,6 +141,18 @@ class LocatedEvent : public Event {
   // widget's coordinate system to the RootView's coordinate system.
   LocatedEvent(const LocatedEvent& model, RootView* root);
 
+  explicit LocatedEvent(NativeEvent native_event);
+  LocatedEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native);
+
+  // TODO(msw): Kill this legacy constructor when we update MouseEvent???
+  // Simple initialization from cracked metadata.
+  LocatedEvent(ui::EventType type, const gfx::Point& location, int flags);
+
+  // Create a new LocatedEvent which is identical to the provided model.
+  // If source / target views are provided, the model location will be converted
+  // from 'source' coordinate system to 'target' coordinate system
+  LocatedEvent(const LocatedEvent& model, View* source, View* target);
+
  private:
   gfx::Point location_;
 };
@@ -286,7 +288,7 @@ class TouchEvent : public LocatedEvent {
 class KeyEvent : public Event {
  public:
   explicit KeyEvent(NativeEvent native_event);
-  explicit KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2);
+  KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native);
 
   // Creates a new KeyEvent synthetically (i.e. not in response to an input
   // event from the host environment). This is typically only used in testing as
@@ -309,20 +311,13 @@ class KeyEvent : public Event {
 // MouseWheelEvent class
 //
 // A MouseWheelEvent is used to propagate mouse wheel user events.
-// Note: e.GetOffset() > 0 means scroll up.
+// Note: e.GetOffset() > 0 means scroll up / left.
 //
 ////////////////////////////////////////////////////////////////////////////////
 class MouseWheelEvent : public LocatedEvent {
  public:
-  // Create a new key event
-  MouseWheelEvent(int offset, int x, int y, int flags)
-      : LocatedEvent(ui::ET_MOUSEWHEEL, gfx::Point(x, y), flags),
-        offset_(offset) {
-  }
-
-#if defined(TOUCH_UI)
-  explicit MouseWheelEvent(XEvent* xev);
-#endif
+  explicit MouseWheelEvent(NativeEvent native_event);
+  MouseWheelEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native);
 
   int offset() const { return offset_; }
 
diff --git a/views/events/event_gtk.cc b/views/events/event_gtk.cc
index 37e06d0..9e38cffa 100644
--- a/views/events/event_gtk.cc
+++ b/views/events/event_gtk.cc
@@ -14,11 +14,14 @@ namespace views {
 namespace {
 
 ui::EventType EventTypeFromNative(NativeEvent native_event) {
+  // Add new event types as necessary.
   switch (native_event->type) {
     case GDK_KEY_PRESS:
       return ui::ET_KEY_PRESSED;
     case GDK_KEY_RELEASE:
       return ui::ET_KEY_RELEASED;
+    case GDK_SCROLL:
+      return ui::ET_MOUSEWHEEL;
     default:
       NOTREACHED();
       break;
@@ -32,13 +35,63 @@ GdkEventKey* GetGdkEventKeyFromNative(NativeEvent native_event) {
   return &native_event->key;
 }
 
+gfx::Point GetMouseEventLocation(NativeEvent native_event) {
+  double x = 0, y = 0;
+  if (gdk_event_get_coords(native_event, &x, &y))
+    return gfx::Point(static_cast<int>(x), static_cast<int>(y));
+  return gfx::Point();
+}
+
+int GetMouseWheelOffset(NativeEvent native_event) {
+  DCHECK(native_event->type == GDK_SCROLL);
+  int offset = (native_event->scroll.direction == GDK_SCROLL_UP ||
+                native_event->scroll.direction == GDK_SCROLL_LEFT) ? 1 : -1;
+
+  // Scale the offset magnitude by window size, to preserve legacy behavior.
+  // TODO(msw): Investigate the use of offset magnitude throughout the codebase.
+  int width = 0, height = 0;
+  gdk_window_get_geometry(native_event->scroll.window, NULL, NULL, &width,
+                          &height, NULL);
+  if (native_event->scroll.direction == GDK_SCROLL_UP ||
+      native_event->scroll.direction == GDK_SCROLL_DOWN)
+    offset = offset * height / 5;
+  else
+    offset = offset * width / 5;
+
+  return offset;
+}
+
+unsigned int GetGdkStateFromNative(NativeEvent native_event) {
+  switch (native_event->type) {
+    case GDK_KEY_PRESS:
+    case GDK_KEY_RELEASE:
+      return native_event->key.state;
+    case GDK_BUTTON_PRESS:
+    case GDK_2BUTTON_PRESS:
+    case GDK_3BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+      return native_event->button.state;
+    case GDK_SCROLL:
+      return native_event->scroll.state;
+    case GDK_MOTION_NOTIFY:
+      return native_event->motion.state;
+    case GDK_ENTER_NOTIFY:
+    case GDK_LEAVE_NOTIFY:
+      return native_event->crossing.state;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return 0;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Event, public:
 
 // static
-int Event::GetFlagsFromGdkState(int state) {
+int Event::GetFlagsFromGdkState(unsigned int state) {
   int flags = 0;
   if (state & GDK_LOCK_MASK)
     flags |= ui::EF_CAPS_LOCK_DOWN;
@@ -82,12 +135,30 @@ void Event::InitWithNativeEvent2(NativeEvent2 native_event_2,
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
+// LocatedEvent, protected:
+
+LocatedEvent::LocatedEvent(NativeEvent native_event)
+    : Event(native_event, EventTypeFromNative(native_event),
+            GetFlagsFromGdkState(GetGdkStateFromNative(native_event))),
+      location_(GetMouseEventLocation(native_event)) {
+}
+
+#if !defined(TOUCH_UI)
+LocatedEvent::LocatedEvent(NativeEvent2 native_event_2,
+                           FromNativeEvent2 from_native)
+    : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) {
+  // No one should ever call this on Gtk-views.
+  // TODO(msw): remove once we rid views of Gtk/Gdk.
+  NOTREACHED();
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
 // KeyEvent, public:
 
 KeyEvent::KeyEvent(NativeEvent native_event)
     : Event(native_event, EventTypeFromNative(native_event),
-            GetFlagsFromGdkState(
-                GetGdkEventKeyFromNative(native_event)->state)),
+            GetFlagsFromGdkState(GetGdkStateFromNative(native_event))),
       key_code_(ui::WindowsKeyCodeForGdkKeyCode(
                 GetGdkEventKeyFromNative(native_event)->keyval)) {
 }
@@ -101,4 +172,22 @@ KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native)
 }
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// MouseWheelEvent, public:
+
+MouseWheelEvent::MouseWheelEvent(NativeEvent native_event)
+    : LocatedEvent(native_event),
+      offset_(GetMouseWheelOffset(native_event)) {
+}
+
+#if !defined(TOUCH_UI)
+MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2,
+                                 FromNativeEvent2 from_native)
+    : LocatedEvent(native_event_2, from_native) {
+  // No one should ever call this on Gtk-views.
+  // TODO(msw): remove once we rid views of Gtk/Gdk.
+  NOTREACHED();
+}
+#endif
+
 }  // namespace views
diff --git a/views/events/event_win.cc b/views/events/event_win.cc
index a0761fe..b79f839 100644
--- a/views/events/event_win.cc
+++ b/views/events/event_win.cc
@@ -71,6 +71,12 @@ ui::EventType EventTypeFromNative(NativeEvent native_event) {
   return ui::ET_UNKNOWN;
 }
 
+int GetFlagsFromNative(NativeEvent native_event) {
+  // Allow other applicable messages as necessary.
+  DCHECK(native_event.message == WM_MOUSEWHEEL);
+  return Event::ConvertWindowsFlags(GET_KEYSTATE_WPARAM(native_event.wParam));
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -128,6 +134,23 @@ void Event::InitWithNativeEvent2(NativeEvent2 native_event_2,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// LocatedEvent, protected:
+
+LocatedEvent::LocatedEvent(NativeEvent native_event)
+    : Event(native_event, EventTypeFromNative(native_event),
+            GetFlagsFromNative(native_event)),
+      location_(native_event.pt.x, native_event.pt.y) {
+}
+
+LocatedEvent::LocatedEvent(NativeEvent2 native_event_2,
+                           FromNativeEvent2 from_native)
+    : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) {
+  // No one should ever call this on Windows.
+  // TODO(msw): remove once we rid views of Gtk/Gdk.
+  NOTREACHED();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // KeyEvent, public:
 
 KeyEvent::KeyEvent(NativeEvent native_event)
@@ -144,4 +167,20 @@ KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native)
   NOTREACHED();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// MouseWheelEvent, public:
+
+MouseWheelEvent::MouseWheelEvent(NativeEvent native_event)
+    : LocatedEvent(native_event),
+      offset_(GET_WHEEL_DELTA_WPARAM(native_event.wParam)) {
+}
+
+MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2,
+                                 FromNativeEvent2 from_native)
+    : LocatedEvent(native_event_2, from_native) {
+  // No one should ever call this on Windows.
+  // TODO(msw): remove once we rid views of Gtk/Gdk.
+  NOTREACHED();
+}
+
 }  // namespace views
diff --git a/views/events/event_x.cc b/views/events/event_x.cc
index 96639d3..4fa63be 100644
--- a/views/events/event_x.cc
+++ b/views/events/event_x.cc
@@ -62,19 +62,6 @@ int GetEventFlagsForButton(int button) {
   return 0;
 }
 
-ui::EventType EventTypeFromNative(NativeEvent2 native_event) {
-  switch (native_event->type) {
-    case KeyPress:
-      return ui::ET_KEY_PRESSED;
-    case KeyRelease:
-      return ui::ET_KEY_RELEASED;
-    default:
-      NOTREACHED();
-      break;
-  }
-  return ui::ET_UNKNOWN;
-}
-
 #if defined(HAVE_XINPUT2)
 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
   int buttonflags = 0;
@@ -129,34 +116,32 @@ int GetTouchIDFromXEvent(XEvent* xev) {
 
 #endif  // HAVE_XINPUT2
 
-int GetMouseWheelOffset(XEvent* xev) {
-#if defined(HAVE_XINPUT2)
-  if (xev->type == GenericEvent) {
-    XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
-    return xiev->detail == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
-  }
-#endif
-  return xev->xbutton.button == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
-}
-
-ui::EventType GetMouseEventType(XEvent* xev) {
-  switch (xev->type) {
+ui::EventType EventTypeFromNative(NativeEvent2 native_event) {
+  switch (native_event->type) {
+    case KeyPress:
+      return ui::ET_KEY_PRESSED;
+    case KeyRelease:
+      return ui::ET_KEY_RELEASED;
     case ButtonPress:
+      if (native_event->xbutton.button == 4 ||
+          native_event->xbutton.button == 5)
+        return ui::ET_MOUSEWHEEL;
       return ui::ET_MOUSE_PRESSED;
     case ButtonRelease:
       return ui::ET_MOUSE_RELEASED;
     case MotionNotify:
-      if (xev->xmotion.state & (Button1Mask | Button2Mask | Button3Mask)) {
+      if (native_event->xmotion.state &
+          (Button1Mask | Button2Mask | Button3Mask))
         return ui::ET_MOUSE_DRAGGED;
-      }
       return ui::ET_MOUSE_MOVED;
 #if defined(HAVE_XINPUT2)
     case GenericEvent: {
       XIDeviceEvent* xievent =
-          static_cast<XIDeviceEvent*>(xev->xcookie.data);
+          static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       switch (xievent->evtype) {
         case XI_ButtonPress:
-          return ui::ET_MOUSE_PRESSED;
+          return (xievent->detail == 4 || xievent->detail == 5) ?
+              ui::ET_MOUSEWHEEL : ui::ET_MOUSE_PRESSED;
         case XI_ButtonRelease:
           return ui::ET_MOUSE_RELEASED;
         case XI_Motion:
@@ -165,11 +150,23 @@ ui::EventType GetMouseEventType(XEvent* xev) {
       }
     }
 #endif
+    default:
+      NOTREACHED();
+      break;
   }
-
   return ui::ET_UNKNOWN;
 }
 
+int GetMouseWheelOffset(XEvent* xev) {
+#if defined(HAVE_XINPUT2)
+  if (xev->type == GenericEvent) {
+    XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
+    return xiev->detail == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
+  }
+#endif
+  return xev->xbutton.button == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
+}
+
 gfx::Point GetMouseEventLocation(XEvent* xev) {
   switch (xev->type) {
     case ButtonPress:
@@ -236,13 +233,25 @@ void Event::InitWithNativeEvent2(NativeEvent2 native_event_2,
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// LocatedEvent, protected:
+
+LocatedEvent::LocatedEvent(NativeEvent2 native_event_2,
+                           FromNativeEvent2 from_native)
+    : Event(native_event_2,
+            EventTypeFromNative(native_event_2),
+            GetEventFlagsFromXState(native_event_2->xbutton.state),
+            from_native),
+      location_(GetMouseEventLocation(native_event_2)) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // KeyEvent, public:
 
-KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native_2)
+KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native)
     : Event(native_event_2,
             EventTypeFromNative(native_event_2),
             GetEventFlagsFromXState(native_event_2->xkey.state),
-            from_native_2),
+            from_native),
       key_code_(ui::KeyboardCodeFromXKeyEvent(native_event_2)) {
 }
 
@@ -250,7 +259,7 @@ KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native_2)
 // MouseEvent, public:
 
 MouseEvent::MouseEvent(XEvent* xev)
-    : LocatedEvent(GetMouseEventType(xev),
+    : LocatedEvent(EventTypeFromNative(xev),
                    GetMouseEventLocation(xev),
                    GetMouseEventFlags(xev)) {
 }
@@ -258,11 +267,10 @@ MouseEvent::MouseEvent(XEvent* xev)
 ////////////////////////////////////////////////////////////////////////////////
 // MouseWheelEvent, public:
 
-MouseWheelEvent::MouseWheelEvent(XEvent* xev)
-    : LocatedEvent(ui::ET_MOUSEWHEEL,
-                   GetMouseEventLocation(xev),
-                   GetEventFlagsFromXState(xev->xbutton.state)),
-      offset_(GetMouseWheelOffset(xev)) {
+MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2,
+                                 FromNativeEvent2 from_native)
+    : LocatedEvent(native_event_2, from_native),
+      offset_(GetMouseWheelOffset(native_event_2)) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/views/focus/accelerator_handler_touch.cc b/views/focus/accelerator_handler_touch.cc
index c6f8e1e..a37d610 100644
--- a/views/focus/accelerator_handler_touch.cc
+++ b/views/focus/accelerator_handler_touch.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -91,8 +91,8 @@ bool DispatchX2Event(RootView* root, XEvent* xev) {
       // and 5. In case of a wheelscroll, we do not want to show the cursor.
       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(cookie->data);
       if (xievent->detail == 4 || xievent->detail == 5) {
-        MouseWheelEvent wheelev(xev);
-        return root->ProcessMouseWheelEvent(wheelev);
+        Event::FromNativeEvent2 from_native;
+        return root->OnMouseWheel(MouseWheelEvent(xev, from_native));
       }
 
       MouseEvent mouseev(xev);
@@ -164,8 +164,8 @@ bool DispatchXEvent(XEvent* xev) {
     switch (xev->type) {
       case KeyPress:
       case KeyRelease: {
-        Event::FromNativeEvent2 from_native_2;
-        KeyEvent keyev(xev, from_native_2);
+        Event::FromNativeEvent2 from_native;
+        KeyEvent keyev(xev, from_native);
         return root->ProcessKeyEvent(keyev);
       }
 
@@ -173,8 +173,8 @@ bool DispatchXEvent(XEvent* xev) {
       case ButtonRelease: {
         if (xev->xbutton.button == 4 || xev->xbutton.button == 5) {
           // Scrolling the wheel triggers button press/release events.
-          MouseWheelEvent wheelev(xev);
-          return root->ProcessMouseWheelEvent(wheelev);
+          Event::FromNativeEvent2 from_native;
+          return root->OnMouseWheel(MouseWheelEvent(xev, from_native));
         } else {
           MouseEvent mouseev(xev);
           if (xev->type == ButtonPress) {
diff --git a/views/widget/root_view.cc b/views/widget/root_view.cc
index 4919bf4..8d9b06b 100644
--- a/views/widget/root_view.cc
+++ b/views/widget/root_view.cc
@@ -116,18 +116,6 @@ bool RootView::ProcessKeyEvent(const KeyEvent& event) {
   return consumed;
 }
 
-bool RootView::ProcessMouseWheelEvent(const MouseWheelEvent& event) {
-  MouseWheelEvent e(event, this);
-  View* v;
-  bool consumed = false;
-  View* focused_view = GetFocusManager()->GetFocusedView();
-  if (focused_view) {
-    for (v = focused_view; v && v != this && !consumed; v = v->parent())
-      consumed = v->OnMouseWheel(e);
-  }
-  return consumed;
-}
-
 // Focus -----------------------------------------------------------------------
 
 void RootView::SetFocusTraversableParent(FocusTraversable* focus_traversable) {
@@ -349,6 +337,15 @@ void RootView::SetMouseHandler(View *new_mh) {
   mouse_pressed_handler_ = new_mh;
 }
 
+bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
+  MouseWheelEvent e(event, this);
+  bool consumed = false;
+  View* v = GetFocusManager()->GetFocusedView();
+  for (; v && v != this && !consumed; v = v->parent())
+    consumed = v->OnMouseWheel(e);
+  return consumed;
+}
+
 #if defined(TOUCH_UI)
 View::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
   TouchEvent e(event, this);
diff --git a/views/widget/root_view.h b/views/widget/root_view.h
index e38c686..e6d5bcb 100644
--- a/views/widget/root_view.h
+++ b/views/widget/root_view.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -72,11 +72,6 @@ class RootView : public View,
   // it.  Returns whether anyone consumed the event.
   bool ProcessKeyEvent(const KeyEvent& event);
 
-  // Process a mousewheel event. Return true if the event was processed
-  // and false otherwise.
-  // MouseWheel events are sent on the focus path.
-  virtual bool ProcessMouseWheelEvent(const MouseWheelEvent& e);
-
 #if defined(TOUCH_UI) && defined(UNIT_TEST)
   // For unit testing purposes, we use this method to set a mock
   // GestureManager
@@ -116,6 +111,7 @@ class RootView : public View,
   virtual void OnMouseReleased(const MouseEvent& e, bool canceled) OVERRIDE;
   virtual void OnMouseMoved(const MouseEvent& e) OVERRIDE;
   virtual void SetMouseHandler(View* new_mouse_handler) OVERRIDE;
+  virtual bool OnMouseWheel(const MouseWheelEvent& e) OVERRIDE;
 #if defined(TOUCH_UI)
   virtual TouchStatus OnTouchEvent(const TouchEvent& e) OVERRIDE;
 #endif
diff --git a/views/widget/widget_gtk.cc b/views/widget/widget_gtk.cc
index 5c6db99..28e7b3c 100644
--- a/views/widget/widget_gtk.cc
+++ b/views/widget/widget_gtk.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -1430,31 +1430,12 @@ bool WidgetGtk::ProcessScroll(GdkEventScroll* event) {
   // Translate it to the widget's coordinates.
   int x = 0, y = 0;
   GetContainedWidgetEventCoordinates(event, &x, &y);
-  int flags = Event::GetFlagsFromGdkState(event->state);
-  int increment = 0;
-  bool is_horizontal = true;
-  switch (event->direction) {
-    case GDK_SCROLL_UP:
-      increment = 1;
-      is_horizontal = false;
-      break;
-    case GDK_SCROLL_DOWN:
-      increment = -1;
-      is_horizontal = false;
-      break;
-    case GDK_SCROLL_LEFT:
-      increment = 1;
-      is_horizontal = true;
-      break;
-    case GDK_SCROLL_RIGHT:
-      increment = -1;
-      is_horizontal = false;
-      break;
-  }
-  increment *= is_horizontal ? root_view_->width() / 5 :
-      root_view_->height() / 5;
-  MouseWheelEvent wheel_event(increment, x, y, flags);
-  return root_view_->ProcessMouseWheelEvent(wheel_event);
+  GdkEventScroll translated_event = *event;
+  translated_event.x = x;
+  translated_event.y = y;
+
+  MouseWheelEvent wheel_event(reinterpret_cast<GdkEvent*>(&translated_event));
+  return root_view_->OnMouseWheel(wheel_event);
 }
 
 // static
diff --git a/views/widget/widget_win.cc b/views/widget/widget_win.cc
index 8662274..a076c3a 100644
--- a/views/widget/widget_win.cc
+++ b/views/widget/widget_win.cc
@@ -784,12 +784,10 @@ LRESULT WidgetWin::OnMouseWheel(UINT message, WPARAM w_param, LPARAM l_param) {
     return 0;
   }
 
-  int flags = GET_KEYSTATE_WPARAM(w_param);
-  short distance = GET_WHEEL_DELTA_WPARAM(w_param);
-  int x = GET_X_LPARAM(l_param);
-  int y = GET_Y_LPARAM(l_param);
-  MouseWheelEvent e(distance, x, y, Event::ConvertWindowsFlags(flags));
-  return root_view_->ProcessMouseWheelEvent(e) ? 0 : 1;
+  MSG msg;
+  MakeMSG(&msg, message, w_param, l_param, 0,
+          GET_X_LPARAM(l_param), GET_Y_LPARAM(l_param));
+  return root_view_->OnMouseWheel(MouseWheelEvent(msg)) ? 0 : 1;
 }
 
 void WidgetWin::OnMove(const CPoint& point) {
@@ -1311,14 +1309,15 @@ void WidgetWin::PostProcessActivateMessage(WidgetWin* widget,
   }
 }
 
-void WidgetWin::MakeMSG(MSG* msg, UINT message, WPARAM w_param,
-                        LPARAM l_param) const {
+void WidgetWin::MakeMSG(MSG* msg, UINT message, WPARAM w_param, LPARAM l_param,
+                        DWORD time, LONG x, LONG y) const {
   msg->hwnd = hwnd();
   msg->message = message;
   msg->wParam = w_param;
   msg->lParam = l_param;
-  msg->time = 0;
-  msg->pt.x = msg->pt.y = 0;
+  msg->time = time;
+  msg->pt.x = x;
+  msg->pt.y = y;
 }
 
 void WidgetWin::RedrawInvalidRect() {
diff --git a/views/widget/widget_win.h b/views/widget/widget_win.h
index ca24993..206b338 100644
--- a/views/widget/widget_win.h
+++ b/views/widget/widget_win.h
@@ -523,7 +523,8 @@ class WidgetWin : public ui::WindowImpl,
                                          int activation_state);
 
   // Fills out a MSG struct with the supplied values.
-  void MakeMSG(MSG* msg, UINT message, WPARAM w_param, LPARAM l_param) const;
+  void MakeMSG(MSG* msg, UINT message, WPARAM w_param, LPARAM l_param,
+               DWORD time = 0, LONG x = 0, LONG y = 0) const;
 
   // Synchronously paints the invalid contents of the Widget.
   void RedrawInvalidRect();