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

5 files changed, 210 insertions, 75 deletions

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)) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////