Handle alternate types in HandleMouseEvent.

ui/base/events/event.h

 // 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.
 
 #ifndef UI_BASE_EVENTS_EVENT_H_
 #define UI_BASE_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 156 matching lines @@
     return type_ == ET_GESTURE_SCROLL_BEGIN ||
            type_ == ET_GESTURE_SCROLL_UPDATE ||
            type_ == ET_GESTURE_SCROLL_END;
   }
 
   bool IsFlingScrollEvent() const {
     return type_ == ET_SCROLL_FLING_CANCEL ||
            type_ == ET_SCROLL_FLING_START;
   }
 
+  bool IsMouseWheelEvent() const {
+    return type_ == ET_MOUSEWHEEL;
+  }
+
   // Returns true if the event has a valid |native_event_|.
   bool HasNativeEvent() const;
 
   // Immediately stops the propagation of the event. This must be called only
   // from an EventHandler during an event-dispatch. Any event handler that may
   // be in the list will not receive the event after this is called.
   // Note that StopPropagation() can be called only for cancelable events.
   void StopPropagation();
   bool stopped_propagation() const { return !!(result_ & ER_CONSUMED); }
 
@@ skipping 202 matching lines @@
   // that was released.
   // NOTE: during a press and release flags() contains the complete set of
   // flags. Use this to determine the button that was pressed or released.
   int changed_button_flags() const { return changed_button_flags_; }
 
  private:
   // Returns the repeat count based on the previous mouse click, if it is
   // recent enough and within a small enough distance.
   static int GetRepeatCount(const MouseEvent& click_event);
 
-  gfx::Point root_location_;
-
   // See description above getter for details.
   int changed_button_flags_;
 
   static MouseEvent* last_click_event_;
 };
 
 class ScrollEvent;
 
 class UI_EXPORT MouseWheelEvent : public MouseEvent {
  public:
   // See |offset| for details.
   static const int kWheelDelta;
 
   explicit MouseWheelEvent(const base::NativeEvent& native_event);
   explicit MouseWheelEvent(const ScrollEvent& scroll_event);
   MouseWheelEvent(const MouseEvent& mouse_event, int x_offset, int y_offset);
+  MouseWheelEvent(const MouseWheelEvent& mouse_wheel_event);
 
   template <class T>
   MouseWheelEvent(const MouseWheelEvent& model,
                   T* source,
                   T* target,
                   EventType type,
                   int flags)
       : MouseEvent(model, source, target, type, flags),
         offset_(model.x_offset(), model.y_offset()){
   }
 
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
   int x_offset() const { return offset_.x(); }
   int y_offset() const { return offset_.y(); }
   const gfx::Vector2d& offset() const { return offset_; }
 
+  // Overridden from LocatedEvent.
+  virtual void UpdateForRootTransform(
+      const gfx::Transform& inverted_root_transform) OVERRIDE;
+
  private:
   gfx::Vector2d offset_;
-
-  DISALLOW_COPY_AND_ASSIGN(MouseWheelEvent);
 };
 
 class UI_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
 
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
@@ skipping 255 matching lines @@
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEvent);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_EVENT_H_