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

ui/base/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_EVENT_H_
 #define UI_BASE_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/ui_export.h"
 #include "ui/gfx/point.h"
 
 namespace ui {
 class Transform;
 
-#if defined(USE_AURA)
-typedef Event* NativeEvent;
-#else
-typedef base::NativeEvent NativeEvent;
-#endif
-
 class UI_EXPORT Event {
  public:
   virtual ~Event();
 
   // For testing.
   class TestApi {
    public:
     explicit TestApi(Event* event) : event_(event) {}
 
     void set_time_stamp(const base::TimeDelta& time_stamp) {
       event_->time_stamp_ = time_stamp;
     }
 
    private:
     TestApi();
     Event* event_;
   };
 
   const base::NativeEvent& native_event() const { return native_event_; }
-  const NativeEvent& ui_native_event() const { return ui_native_event_; }
   EventType type() const { return type_; }
   // time_stamp represents time since machine was booted.
   const base::TimeDelta& time_stamp() const { return time_stamp_; }
   int flags() const { return flags_; }
 
   // This is only intended to be used externally by classes that are modifying
   // events in EventFilter::PreHandleKeyEvent().
   void set_flags(int flags) { flags_ = flags; }
 
   // The following methods return true if the respective keys were pressed at
@@ skipping 46 matching lines @@
   void set_time_stamp(base::TimeDelta time_stamp) { time_stamp_ = time_stamp; }
 
  private:
   void operator=(const Event&);
 
   // Safely initializes the native event members of this class.
   void Init();
   void InitWithNativeEvent(const base::NativeEvent& native_event);
 
   base::NativeEvent native_event_;
-  // TODO(beng): check to see if this is necessary.
-  NativeEvent ui_native_event_;
   EventType type_;
   base::TimeDelta time_stamp_;
   int flags_;
   bool delete_native_event_;
 };
 
 class UI_EXPORT LocatedEvent : public Event {
  public:
   // For testing.
   class TestApi : public Event::TestApi {
@@ skipping 36 matching lines @@
     if (target && target != source)
       T::ConvertPointToTarget(source, target, &location_);
   }
 
   // Used for synthetic events in testing.
   LocatedEvent(EventType type,
                const gfx::Point& location,
                const gfx::Point& root_location,
                int flags);
 
-  LocatedEvent(const LocatedEvent& model);
+  // Called from MouseEvent's copy ctor.
+  explicit LocatedEvent(const LocatedEvent& model);
 
   gfx::Point location_;
 
   gfx::Point root_location_;
 };
 
 class UI_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
@@ skipping 66 matching lines @@
   void SetClickCount(int click_count);
 
   // Identifies the button that changed. During a press this corresponds to the
   // button that was pressed and during a release this corresponds to the button
   // 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_; }
 
  protected:
+  // Called from MouseWheelEvent's ctor.
   explicit MouseEvent(const MouseEvent& model);
 
  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 NativeEvent& native_event);
+  explicit MouseWheelEvent(const base::NativeEvent& native_event);
+  explicit MouseWheelEvent(const MouseEvent& mouse_event);
   explicit MouseWheelEvent(const ScrollEvent& scroll_event);
 
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: offset() > 0 means scroll up / left.
   int offset() const { return offset_; }
 
  private:
   int offset_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseWheelEvent);
@@ skipping 120 matching lines @@
   void set_key_code(KeyboardCode key_code) { key_code_ = key_code; }
 
  private:
   KeyboardCode key_code_;
   // True if this is a translated character event (vs. a raw key down). Both
   // share the same type: ET_KEY_PRESSED.
   bool is_char_;
 
   uint16 character_;
   uint16 unmodified_character_;
+
+  DISALLOW_COPY_AND_ASSIGN(KeyEvent);
 };
 
 // A key event which is translated by an input method (IME).
 // For example, if an IME receives a KeyEvent(VKEY_SPACE), and it does not
 // consume the key, the IME usually generates and dispatches a
 // TranslatedKeyEvent(VKEY_SPACE) event. If the IME receives a KeyEvent and
 // it does consume the event, it might dispatch a
 // TranslatedKeyEvent(VKEY_PROCESSKEY) event as defined in the DOM spec.
 class UI_EXPORT TranslatedKeyEvent : public KeyEvent {
  public:
   TranslatedKeyEvent(const base::NativeEvent& native_event, bool is_char);
 
   // Used for synthetic events such as a VKEY_PROCESSKEY key event.
   TranslatedKeyEvent(bool is_press, KeyboardCode key_code, int flags);
 
   // Changes the type() of the object from ET_TRANSLATED_KEY_* to ET_KEY_* so
   // that RenderWidgetHostViewAura and NativeWidgetAura could handle the event.
   void ConvertToKeyEvent();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TranslatedKeyEvent);
 };
 
 class UI_EXPORT DropTargetEvent : public LocatedEvent {
  public:
   DropTargetEvent(const OSExchangeData& data,
                   const gfx::Point& location,
                   const gfx::Point& root_location,
                   int source_operations)
       : LocatedEvent(ET_DROP_TARGET_EVENT, location, root_location, 0),
         data_(data),
@@ skipping 73 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_EVENT_H_