MacViews: Implement basic NSEvent -> ui::Event conversion for Mac

ui/events/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/events/event.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #endif
@@ skipping 11 matching lines @@
 #include "ui/gfx/transform_util.h"
 
 #if defined(USE_X11)
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #elif defined(USE_OZONE)
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #endif
 
 namespace {
 
-base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) {
-#if defined(USE_X11)
-  if (!event || event->type == GenericEvent)
-    return NULL;
-  XEvent* copy = new XEvent;
-  *copy = *event;
-  return copy;
-#elif defined(OS_WIN)
-  return event;
-#elif defined(USE_OZONE)
-  return NULL;
-#else
-  NOTREACHED() <<
-      "Don't know how to copy base::NativeEvent for this platform";
-  return NULL;
-#endif
-}
-
 std::string EventTypeName(ui::EventType type) {
 #define RETURN_IF_TYPE(t) if (type == ui::t)  return #t
 #define CASE_TYPE(t) case ui::t:  return #t
   switch (type) {
     CASE_TYPE(ET_UNKNOWN);
     CASE_TYPE(ET_MOUSE_PRESSED);
     CASE_TYPE(ET_MOUSE_DRAGGED);
     CASE_TYPE(ET_MOUSE_RELEASED);
     CASE_TYPE(ET_MOUSE_MOVED);
     CASE_TYPE(ET_MOUSE_ENTERED);
@@ skipping 52 matching lines @@
 }
 
 }  // namespace
 
 namespace ui {
 
 ////////////////////////////////////////////////////////////////////////////////
 // Event
 
 Event::~Event() {
-#if defined(USE_X11)
   if (delete_native_event_)
-    delete native_event_;
-#endif
+    ReleaseCopiedNativeEvent(native_event_);
 }
 
 bool Event::HasNativeEvent() const {
   base::NativeEvent null_event;
   std::memset(&null_event, 0, sizeof(null_event));
   return !!std::memcmp(&native_event_, &null_event, sizeof(null_event));
 }
 
 void Event::StopPropagation() {
   // TODO(sad): Re-enable these checks once View uses dispatcher to dispatch
   // events.
   // CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
   CHECK(cancelable_);
   result_ = static_cast<EventResult>(result_ | ER_CONSUMED);
 }
 
 void Event::SetHandled() {
   // TODO(sad): Re-enable these checks once View uses dispatcher to dispatch
   // events.
   // CHECK(phase_ != EP_PREDISPATCH && phase_ != EP_POSTDISPATCH);
   CHECK(cancelable_);
   result_ = static_cast<EventResult>(result_ | ER_HANDLED);
 }
 
 Event::Event(EventType type, base::TimeDelta time_stamp, int flags)
     : type_(type),
       time_stamp_(time_stamp),
       flags_(flags),
-#if defined(USE_X11)
-      native_event_(NULL),
-#endif
+      native_event_(base::NativeEvent()),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
       result_(ER_UNHANDLED) {
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
-  Init();
 }
 
 Event::Event(const base::NativeEvent& native_event,
              EventType type,
              int flags)
     : type_(type),
       time_stamp_(EventTimeFromNative(native_event)),
       flags_(flags),
+      native_event_(native_event),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
       result_(ER_UNHANDLED) {
   base::TimeDelta delta = EventTimeForNow() - time_stamp_;
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Browser",
                               delta.InMicroseconds(), 1, 1000000, 100);
   std::string name_for_event =
       base::StringPrintf("Event.Latency.Browser.%s", name_.c_str());
   base::HistogramBase* counter_for_type =
       base::Histogram::FactoryGet(
           name_for_event,
           1,
           1000000,
           100,
           base::HistogramBase::kUmaTargetedHistogramFlag);
   counter_for_type->Add(delta.InMicroseconds());
-  InitWithNativeEvent(native_event);
 }
 
 Event::Event(const Event& copy)
     : type_(copy.type_),
       time_stamp_(copy.time_stamp_),
       latency_(copy.latency_),
       flags_(copy.flags_),
-      native_event_(::CopyNativeEvent(copy.native_event_)),
-      delete_native_event_(false),
+      native_event_(CopyNativeEvent(copy.native_event_)),
+      delete_native_event_(true),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
       result_(ER_UNHANDLED) {
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
-#if defined(USE_X11)
-  if (native_event_)
-    delete_native_event_ = true;
-#endif
 }
 
 void Event::SetType(EventType type) {
   if (type_ < ET_LAST)
     name_ = std::string();
   type_ = type;
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
 }
 
-void Event::Init() {
-  std::memset(&native_event_, 0, sizeof(native_event_));
-}
-
-void Event::InitWithNativeEvent(const base::NativeEvent& native_event) {
-  native_event_ = native_event;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // CancelModeEvent
 
 CancelModeEvent::CancelModeEvent()
     : Event(ET_CANCEL_MODE, base::TimeDelta(), 0) {
   set_cancelable(false);
 }
 
 CancelModeEvent::~CancelModeEvent() {
 }
@@ skipping 490 matching lines @@
 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