Clean up some detritus that accumulated during the fixing of 125937.

ui/base/event.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 "ui/base/event.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #endif
 
@@ skipping 21 matching lines @@
   NOTREACHED() <<
       "Don't know how to copy base::NativeEvent for this platform";
   return NULL;
 #endif
 }
 
 }  // namespace
 
 namespace ui {
 
+////////////////////////////////////////////////////////////////////////////////
+// Event
+
 Event::~Event() {
 #if defined(USE_X11)
   if (delete_native_event_)
     delete native_event_;
 #endif
 }
 
 bool Event::HasNativeEvent() const {
   base::NativeEvent null_event;
   std::memset(&null_event, 0, sizeof(null_event));
@@ skipping 13 matching lines @@
              int flags)
     : type_(type),
       time_stamp_(EventTimeFromNative(native_event)),
       flags_(flags),
       delete_native_event_(false) {
   InitWithNativeEvent(native_event);
 }
 
 Event::Event(const Event& copy)
     : native_event_(copy.native_event_),
-      ui_native_event_(copy.ui_native_event_),
       type_(copy.type_),
       time_stamp_(copy.time_stamp_),
       flags_(copy.flags_),
       delete_native_event_(false) {
 }
 
 void Event::Init() {
   std::memset(&native_event_, 0, sizeof(native_event_));
-  std::memset(&ui_native_event_, 0, sizeof(ui_native_event_));
 }
 
 void Event::InitWithNativeEvent(const base::NativeEvent& native_event) {
   native_event_ = native_event;
-  std::memset(&ui_native_event_, 0, sizeof(ui_native_event_));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// LocatedEvent
+
 LocatedEvent::~LocatedEvent() {
 }
 
 LocatedEvent::LocatedEvent(const base::NativeEvent& native_event)
     : Event(native_event,
             EventTypeFromNative(native_event),
             EventFlagsFromNative(native_event)),
       location_(EventLocationFromNative(native_event)),
       root_location_(location_) {
 }
@@ skipping 15 matching lines @@
 
 void LocatedEvent::UpdateForRootTransform(const Transform& root_transform) {
   // Transform has to be done at root level.
   DCHECK_EQ(root_location_.x(), location_.x());
   DCHECK_EQ(root_location_.y(), location_.y());
   gfx::Point3f p(location_);
   root_transform.TransformPointReverse(p);
   root_location_ = location_ = p.AsPoint();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// MouseEvent
+
 MouseEvent::MouseEvent(const base::NativeEvent& native_event)
     : LocatedEvent(native_event),
       changed_button_flags_(
           GetChangedMouseButtonFlagsFromNative(native_event)) {
   if (type() == ET_MOUSE_PRESSED)
     SetClickCount(GetRepeatCount(*this));
 }
 
 MouseEvent::MouseEvent(EventType type,
                        const gfx::Point& location,
@@ skipping 86 matching lines @@
       f &= ~EF_IS_DOUBLE_CLICK;
       f |= EF_IS_TRIPLE_CLICK;
       break;
   }
   set_flags(f);
 }
 
 MouseEvent::MouseEvent(const MouseEvent& model) : LocatedEvent(model) {
 }
 
-MouseWheelEvent::MouseWheelEvent(const NativeEvent& native_event)
-#if defined(USE_AURA)
-    : MouseEvent(static_cast<const MouseEvent&>(*native_event)),
-      offset_(GetMouseWheelOffset(native_event->native_event())) {
-#else
+////////////////////////////////////////////////////////////////////////////////
+// MouseWheelEvent
+
+MouseWheelEvent::MouseWheelEvent(const base::NativeEvent& native_event)
     : MouseEvent(native_event),
       offset_(GetMouseWheelOffset(native_event)) {
-#endif
+}
+
+MouseWheelEvent::MouseWheelEvent(const MouseEvent& mouse_event)
+    : MouseEvent(mouse_event),
+      offset_(GetMouseWheelOffset(mouse_event.native_event())) {
 }
 
 MouseWheelEvent::MouseWheelEvent(const ScrollEvent& scroll_event)
     : MouseEvent(scroll_event),
       offset_(scroll_event.y_offset()) {
   set_type(ET_MOUSEWHEEL);
 }
 
 #if defined(OS_WIN)
 // This value matches windows WHEEL_DELTA.
 // static
 const int MouseWheelEvent::kWheelDelta = 120;
 #else
 // This value matches GTK+ wheel scroll amount.
 const int MouseWheelEvent::kWheelDelta = 53;
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// TouchEvent
+
 TouchEvent::TouchEvent(const base::NativeEvent& native_event)
     : LocatedEvent(native_event),
       touch_id_(GetTouchId(native_event)),
       radius_x_(GetTouchRadiusX(native_event)),
       radius_y_(GetTouchRadiusY(native_event)),
       rotation_angle_(GetTouchAngle(native_event)),
       force_(GetTouchForce(native_event)) {
 }
 
 TouchEvent::TouchEvent(EventType type,
@@ skipping 15 matching lines @@
 void TouchEvent::UpdateForRootTransform(const Transform& root_transform) {
   LocatedEvent::UpdateForRootTransform(root_transform);
   gfx::Point3f scale;
   InterpolatedTransform::FactorTRS(root_transform, NULL, NULL, &scale);
   if (scale.x())
     radius_x_ /= scale.x();
   if (scale.y())
     radius_y_ /= scale.y();
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// TestTouchEvent
+
 TestTouchEvent::TestTouchEvent(EventType type,
                                int x,
                                int y,
                                int flags,
                                int touch_id,
                                float radius_x,
                                float radius_y,
                                float angle,
                                float force)
     : TouchEvent(type, gfx::Point(x, y), touch_id, base::TimeDelta()) {
   set_flags(flags);
   set_radius(radius_x, radius_y);
   set_rotation_angle(angle);
   set_force(force);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// KeyEvent
+
 KeyEvent::KeyEvent(const base::NativeEvent& native_event, bool is_char)
     : Event(native_event,
             EventTypeFromNative(native_event),
             EventFlagsFromNative(native_event)),
       key_code_(KeyboardCodeFromNative(native_event)),
       is_char_(is_char),
       character_(0),
       unmodified_character_(0) {
 }
 
@@ skipping 62 matching lines @@
 }
 
 KeyEvent* KeyEvent::Copy() {
   KeyEvent* copy = new KeyEvent(::CopyNativeEvent(native_event()), is_char());
 #if defined(USE_X11)
   copy->set_delete_native_event(true);
 #endif
   return copy;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// TranslatedKeyEvent
+
 TranslatedKeyEvent::TranslatedKeyEvent(const base::NativeEvent& native_event,
                                        bool is_char)
     : KeyEvent(native_event, is_char) {
   set_type(type() == ET_KEY_PRESSED ?
            ET_TRANSLATED_KEY_PRESS : ET_TRANSLATED_KEY_RELEASE);
 }
 
 TranslatedKeyEvent::TranslatedKeyEvent(bool is_press,
                                        KeyboardCode key_code,
                                        int flags)
     : KeyEvent((is_press ? ET_TRANSLATED_KEY_PRESS : ET_TRANSLATED_KEY_RELEASE),
                key_code,
                flags) {
 }
 
 void TranslatedKeyEvent::ConvertToKeyEvent() {
   set_type(type() == ET_TRANSLATED_KEY_PRESS ?
            ET_KEY_PRESSED : ET_KEY_RELEASED);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// ScrollEvent
+
 ScrollEvent::ScrollEvent(const base::NativeEvent& native_event)
     : MouseEvent(native_event) {
   if (type() == ET_SCROLL) {
     GetScrollOffsets(native_event, &x_offset_, &y_offset_);
     double start, end;
     GetGestureTimes(native_event, &start, &end);
   } else if (type() == ET_SCROLL_FLING_START) {
     bool is_cancel;
     GetFlingData(native_event, &x_offset_, &y_offset_, &is_cancel);
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// GestureEvent
+
 GestureEvent::GestureEvent(EventType type,
                            int x,
                            int y,
                            int flags,
                            base::TimeDelta time_stamp,
                            const GestureEventDetails& details,
                            unsigned int touch_ids_bitfield)
     : LocatedEvent(type, gfx::Point(x, y), gfx::Point(x, y), flags),
       details_(details),
       touch_ids_bitfield_(touch_ids_bitfield) {
   set_time_stamp(time_stamp);
 }
 
 GestureEvent::~GestureEvent() {
 }
 
 int GestureEvent::GetLowestTouchId() const {
   if (touch_ids_bitfield_ == 0)
     return -1;
   int i = -1;
   // Find the index of the least significant 1 bit
   while (!(1 << ++i & touch_ids_bitfield_));
   return i;
 }
 
 }  // namespace ui