Revert "Revert 224496 "Move ui/base/latency_info* to ui/events""

ui/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_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/gestures/gesture_types.h"
-#include "ui/base/latency_info.h"
-#include "ui/base/ui_export.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/events/latency_info.h"
 #include "ui/gfx/point.h"
 
 namespace gfx {
 class Transform;
 }
 
 namespace ui {
 class EventTarget;
 
-class UI_EXPORT Event {
+class EVENTS_EXPORT Event {
  public:
   virtual ~Event();
 
   class DispatcherApi {
    public:
     explicit DispatcherApi(Event* event) : event_(event) {}
 
     void set_target(EventTarget* target) {
       event_->target_ = target;
     }
@@ skipping 192 matching lines @@
   int flags_;
   bool dispatch_to_hidden_targets_;
   base::NativeEvent native_event_;
   bool delete_native_event_;
   bool cancelable_;
   EventTarget* target_;
   EventPhase phase_;
   EventResult result_;
 };
 
-class UI_EXPORT CancelModeEvent : public Event {
+class EVENTS_EXPORT CancelModeEvent : public Event {
  public:
   CancelModeEvent();
   virtual ~CancelModeEvent();
 };
 
-class UI_EXPORT LocatedEvent : public Event {
+class EVENTS_EXPORT LocatedEvent : public Event {
  public:
   // For testing.
   class TestApi : public Event::TestApi {
    public:
     explicit TestApi(LocatedEvent* located_event)
         : Event::TestApi(located_event),
           located_event_(located_event) {}
 
     void set_location(const gfx::Point& location) {
       located_event_->location_ = location;
@@ skipping 46 matching lines @@
                base::TimeDelta time_stamp,
                int flags);
 
   gfx::Point location_;
 
   // |location_| multiplied by an optional transformation matrix for
   // rotations, animations and skews.
   gfx::Point root_location_;
 };
 
-class UI_EXPORT MouseEvent : public LocatedEvent {
+class EVENTS_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
   // Create a new MouseEvent based on the provided model.
   // Uses the provided |type| and |flags| for the new event.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   MouseEvent(const MouseEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
@@ skipping 76 matching lines @@
   static int GetRepeatCount(const MouseEvent& click_event);
 
   // See description above getter for details.
   int changed_button_flags_;
 
   static MouseEvent* last_click_event_;
 };
 
 class ScrollEvent;
 
-class UI_EXPORT MouseWheelEvent : public MouseEvent {
+class EVENTS_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>
@@ skipping 13 matching lines @@
   const gfx::Vector2d& offset() const { return offset_; }
 
   // Overridden from LocatedEvent.
   virtual void UpdateForRootTransform(
       const gfx::Transform& inverted_root_transform) OVERRIDE;
 
  private:
   gfx::Vector2d offset_;
 };
 
-class UI_EXPORT TouchEvent : public LocatedEvent {
+class EVENTS_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>
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
         touch_id_(model.touch_id_),
@@ skipping 62 matching lines @@
   // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
   float radius_y_;
 
   // Angle of the major axis away from the X axis. Default 0.0.
   float rotation_angle_;
 
   // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
   float force_;
 };
 
-class UI_EXPORT KeyEvent : public Event {
+class EVENTS_EXPORT KeyEvent : public Event {
  public:
   KeyEvent(const base::NativeEvent& native_event, bool is_char);
 
   // Used for synthetic events.
   KeyEvent(EventType type, KeyboardCode key_code, int flags, bool is_char);
 
   // These setters allow an I18N virtual keyboard to fabricate a keyboard event
   // which does not have a corresponding KeyboardCode (example: U+00E1 Latin
   // small letter A with acute, U+0410 Cyrillic capital letter A.)
   // GetCharacter() and GetUnmodifiedCharacter() return the character.
@@ skipping 39 matching lines @@
   uint16 character_;
   uint16 unmodified_character_;
 };
 
 // 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 {
+class EVENTS_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 {
+class EVENTS_EXPORT DropTargetEvent : public LocatedEvent {
  public:
   DropTargetEvent(const OSExchangeData& data,
                   const gfx::Point& location,
                   const gfx::Point& root_location,
                   int source_operations);
 
   const OSExchangeData& data() const { return data_; }
   int source_operations() const { return source_operations_; }
 
  private:
   // Data associated with the drag/drop session.
   const OSExchangeData& data_;
 
   // Bitmask of supported DragDropTypes::DragOperation by the source.
   int source_operations_;
 
   DISALLOW_COPY_AND_ASSIGN(DropTargetEvent);
 };
 
-class UI_EXPORT ScrollEvent : public MouseEvent {
+class EVENTS_EXPORT ScrollEvent : public MouseEvent {
  public:
   explicit ScrollEvent(const base::NativeEvent& native_event);
   template <class T>
   ScrollEvent(const ScrollEvent& model,
               T* source,
               T* target)
       : MouseEvent(model, source, target),
         x_offset_(model.x_offset_),
         y_offset_(model.y_offset_),
         x_offset_ordinal_(model.x_offset_ordinal_),
@@ skipping 31 matching lines @@
   // Potential accelerated offsets.
   float x_offset_;
   float y_offset_;
   // Unaccelerated offsets.
   float x_offset_ordinal_;
   float y_offset_ordinal_;
   // Number of fingers on the pad.
   int finger_count_;
 };
 
-class UI_EXPORT GestureEvent : public LocatedEvent {
+class EVENTS_EXPORT GestureEvent : public LocatedEvent {
  public:
   GestureEvent(EventType type,
                int x,
                int y,
                int flags,
                base::TimeDelta time_stamp,
                const GestureEventDetails& details,
                unsigned int touch_ids_bitfield);
 
   // Create a new GestureEvent which is identical to the provided model.
@@ skipping 24 matching lines @@
   // The set of indices of ones in the binary representation of
   // touch_ids_bitfield_ is the set of touch_ids associate with this gesture.
   // 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_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_