events: Inlcude the event-phase and event-result in Event.

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"
 #include "base/logging.h"
 #include "base/time.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events/event_constants.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;
 class EventTarget;
 
 class UI_EXPORT Event {
  public:
   virtual ~Event();
 
   class DispatcherApi {
    public:
     explicit DispatcherApi(Event* event) : event_(event) {}

[Ben Goodger (Google), 2012/09/10 18:07:14]

should this be private and friend class EventDispatcher?

[sadrul, 2012/09/10 18:35:24]

RootWindow needs to also set_target for touch-events, unfortunately. So we
introduced this DispatcherApi so that both ED and RW can use this. I am hoping
the name 'DispatcherApi' would be sufficient for this to not be misused from
other places (like TestApi below)?

 
     void set_target(EventTarget* target) {
       event_->target_ = target;
     }
 
+    void set_phase(EventPhase phase) { event_->phase_ = phase; }
+    void set_result(int result) {
+      event_->result_ = static_cast<EventResult>(result);
+    }
+
    private:
     DispatcherApi();
     Event* event_;
 
     DISALLOW_COPY_AND_ASSIGN(DispatcherApi);
   };
 
   // For testing.
   class TestApi {
    public:
@@ skipping 12 matching lines @@
   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; }
 
   EventTarget* target() const { return target_; }
+  EventPhase phase() const { return phase_; }
+  EventResult result() const { return result_; }
 
   // The following methods return true if the respective keys were pressed at
   // the time the event was created.
   bool IsShiftDown() const { return (flags_ & EF_SHIFT_DOWN) != 0; }
   bool IsControlDown() const { return (flags_ & EF_CONTROL_DOWN) != 0; }
   bool IsCapsLockDown() const { return (flags_ & EF_CAPS_LOCK_DOWN) != 0; }
   bool IsAltDown() const { return (flags_ & EF_ALT_DOWN) != 0; }
 
   bool IsKeyEvent() const {
     return type_ == ET_KEY_PRESSED ||
@@ skipping 86 matching lines @@
   // Safely initializes the native event members of this class.
   void Init();
   void InitWithNativeEvent(const base::NativeEvent& native_event);
 
   base::NativeEvent native_event_;
   EventType type_;
   base::TimeDelta time_stamp_;
   int flags_;
   bool delete_native_event_;
   EventTarget* target_;
+  EventPhase phase_;
+  EventResult result_;
 };
 
 class UI_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) {}
@@ skipping 430 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_