MacViews: Add WidgetEventGenerator to abstract platform-specific event generation for tests.

ui/events/test/event_generator.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2014 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/aura/test/event_generator.h"
+#include "ui/events/test/event_generator.h"
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/time/default_tick_clock.h"
-#include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_source.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
-#include "ui/base/x/x11_util.h"
-#include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 #if defined(OS_WIN)
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #endif
 
-namespace aura {
+namespace ui {
 namespace test {
 namespace {
 
-void DummyCallback(ui::EventType, const gfx::Vector2dF&) {
+void DummyCallback(EventType, const gfx::Vector2dF&) {
 }
 
-class DefaultEventGeneratorDelegate : public EventGeneratorDelegate {
- public:
-  explicit DefaultEventGeneratorDelegate(Window* root_window)
-      : root_window_(root_window) {}
-  virtual ~DefaultEventGeneratorDelegate() {}
-
-  // EventGeneratorDelegate overrides:
-  virtual WindowTreeHost* GetHostAt(const gfx::Point& point) const OVERRIDE {
-    return root_window_->GetHost();
-  }
-
-  virtual client::ScreenPositionClient* GetScreenPositionClient(
-      const aura::Window* window) const OVERRIDE {
-    return NULL;
-  }
-
- private:
-  Window* root_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(DefaultEventGeneratorDelegate);
-};
-
 class TestKeyEvent : public ui::KeyEvent {
  public:
   TestKeyEvent(const base::NativeEvent& native_event, int flags, bool is_char)
       : KeyEvent(native_event, is_char) {
     set_flags(flags);
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int touch_id,
                  int flags,
                  base::TimeDelta timestamp)
       : TouchEvent(type, root_location, flags, touch_id, timestamp,
                    1.0f, 1.0f, 1.0f, 1.0f) {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
-EventGenerator::EventGenerator(Window* root_window)
-    : delegate_(new DefaultEventGeneratorDelegate(root_window)),
-      current_host_(delegate_->GetHostAt(current_location_)),
+EventGenerator::EventGenerator(gfx::NativeWindow root_window)
+    : delegate_(CreateDefaultPlatformDelegate(this, root_window, NULL)),

[tfarina, 2014/07/31 00:20:19]

So now, with this, events_test_support depends on aura_test_support since the
implementation is in ui/aura/test/event_generator_delegate_aura.cc and
views_test_support as the implementation is in
ui/views/test/event_generator_delegate_mac.mm

I think that is why my GN patch is breaking and was reverted in
https://codereview.chromium.org/427403003/.

I don't know this went unnoticed and that you don't have aura_test_suport and
views_test_support in events.gyp.

[tfarina, 2014/07/31 00:49:24]

And if we try to depend on either it will create a circular dependency.

See my comments in crbug.com/399106

How come this is passing in the GYP build is escaping me. (I might be wrong?) 

+      current_target_(delegate_->GetTargetAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false),
       tick_clock_(new base::DefaultTickClock()) {
 }
 
-EventGenerator::EventGenerator(Window* root_window, const gfx::Point& point)
-    : delegate_(new DefaultEventGeneratorDelegate(root_window)),
+EventGenerator::EventGenerator(gfx::NativeWindow root_window,
+                               const gfx::Point& point)
+    : delegate_(CreateDefaultPlatformDelegate(this, root_window, NULL)),
       current_location_(point),
-      current_host_(delegate_->GetHostAt(current_location_)),
+      current_target_(delegate_->GetTargetAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false),
       tick_clock_(new base::DefaultTickClock()) {
 }
 
-EventGenerator::EventGenerator(Window* root_window, Window* window)
-    : delegate_(new DefaultEventGeneratorDelegate(root_window)),
-      current_location_(CenterOfWindow(window)),
-      current_host_(delegate_->GetHostAt(current_location_)),
+EventGenerator::EventGenerator(gfx::NativeWindow root_window,
+                               gfx::NativeWindow window)
+    : delegate_(CreateDefaultPlatformDelegate(this, root_window, window)),
+      current_location_(delegate_->CenterOfWindow(window)),
+      current_target_(delegate_->GetTargetAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false),
       tick_clock_(new base::DefaultTickClock()) {
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
-      current_host_(delegate_->GetHostAt(current_location_)),
+      current_target_(delegate_->GetTargetAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false),
       tick_clock_(new base::DefaultTickClock()) {
 }
 
 EventGenerator::~EventGenerator() {
   for (std::list<ui::Event*>::iterator i = pending_events_.begin();
       i != pending_events_.end(); ++i)
     delete *i;
@@ skipping 30 matching lines @@
 
 void EventGenerator::MoveMouseWheel(int delta_x, int delta_y) {
   gfx::Point location = GetLocationInCurrentRoot();
   ui::MouseEvent mouseev(ui::ET_MOUSEWHEEL, location, location, flags_, 0);
   ui::MouseWheelEvent wheelev(mouseev, delta_x, delta_y);
   Dispatch(&wheelev);
 }
 
 void EventGenerator::SendMouseExit() {
   gfx::Point exit_location(current_location_);
-  ConvertPointToTarget(current_host_->window(), &exit_location);
+  delegate_->ConvertPointToTarget(current_target_, &exit_location);
   ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, exit_location, exit_location,
                          flags_, 0);
   Dispatch(&mouseev);
 }
 
 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
   ui::MouseEvent mouseev(event_type, point_in_host, point_in_host, flags_, 0);
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
-  current_host_->ConvertPointFromHost(&current_location_);
+  delegate_->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseTo(const gfx::Point& point_in_screen,
                                  int count) {
   DCHECK_GT(count, 0);
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
 
   gfx::Vector2dF diff(point_in_screen - current_location_);
   for (float i = 1; i <= count; i++) {
     gfx::Vector2dF step(diff);
     step.Scale(i / count);
     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
     if (!grab_)
       UpdateCurrentDispatcher(move_point);
-    ConvertPointToTarget(current_host_->window(), &move_point);
+    delegate_->ConvertPointToTarget(current_target_, &move_point);
     ui::MouseEvent mouseev(event_type, move_point, move_point, flags_, 0);
     Dispatch(&mouseev);
   }
   current_location_ = point_in_screen;
 }
 
-void EventGenerator::MoveMouseRelativeTo(const Window* window,
+void EventGenerator::MoveMouseRelativeTo(const EventTarget* window,
                                          const gfx::Point& point_in_parent) {
   gfx::Point point(point_in_parent);
-  ConvertPointFromTarget(window, &point);
+  delegate_->ConvertPointFromTarget(window, &point);
   MoveMouseTo(point);
 }
 
 void EventGenerator::DragMouseTo(const gfx::Point& point) {
   PressLeftButton();
   MoveMouseTo(point);
   ReleaseLeftButton();
 }
 
-void EventGenerator::MoveMouseToCenterOf(Window* window) {
+void EventGenerator::MoveMouseToCenterOf(EventTarget* window) {
   MoveMouseTo(CenterOfWindow(window));
 }
 
 void EventGenerator::PressTouch() {
   PressTouchId(0);
 }
 
 void EventGenerator::PressTouchId(int touch_id) {
   TestTouchEvent touchev(
       ui::ET_TOUCH_PRESSED, GetLocationInCurrentRoot(), touch_id, flags_,
@@ skipping 26 matching lines @@
       Now());
   Dispatch(&touchev);
 }
 
 void EventGenerator::PressMoveAndReleaseTouchTo(const gfx::Point& point) {
   PressTouch();
   MoveTouch(point);
   ReleaseTouch();
 }
 
-void EventGenerator::PressMoveAndReleaseTouchToCenterOf(Window* window) {
+void EventGenerator::PressMoveAndReleaseTouchToCenterOf(EventTarget* window) {
   PressMoveAndReleaseTouchTo(CenterOfWindow(window));
 }
 
 void EventGenerator::GestureEdgeSwipe() {
   ui::GestureEvent gesture(
       0,
       0,
       0,
       Now(),
       ui::GestureEventDetails(ui::ET_GESTURE_WIN8_EDGE_SWIPE, 0, 0));
@@ skipping 179 matching lines @@
                               x_offset, y_offset,
                               x_offset, y_offset,
                               num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     const std::vector<gfx::Point>& offsets,
                                     int num_fingers) {
-  int steps = offsets.size();
+  size_t steps = offsets.size();
   base::TimeDelta timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
-  for (int i = 0; i < steps; ++i) {
+  for (size_t i = 0; i < steps; ++i) {
     timestamp += step_delay;
     ui::ScrollEvent scroll(ui::ET_SCROLL,
                            start,
                            timestamp,
                            0,
                            offsets[i].x(), offsets[i].y(),
                            offsets[i].x(), offsets[i].y(),
                            num_fingers);
     Dispatch(&scroll);
   }
@@ skipping 56 matching lines @@
                       flags);
   ui::KeyEvent keyev(xevent, false);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
   ui::KeyEvent keyev(type, key_code, flags, false);
 #endif  // OS_WIN
   Dispatch(&keyev);
 }
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
-  current_host_ = delegate_->GetHostAt(point);
+  current_target_ = delegate_->GetTargetAt(point);
 }
 
 void EventGenerator::PressButton(int flag) {
   if (!(flags_ & flag)) {
     flags_ |= flag;
-    grab_ = flags_ & kAllButtonMask;
+    grab_ = (flags_ & kAllButtonMask) != 0;
     gfx::Point location = GetLocationInCurrentRoot();
     ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location, flags_,
                            flag);
     Dispatch(&mouseev);
   }
 }
 
 void EventGenerator::ReleaseButton(int flag) {
   if (flags_ & flag) {
     gfx::Point location = GetLocationInCurrentRoot();
     ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, location,
                            location, flags_, flag);
     Dispatch(&mouseev);
     flags_ ^= flag;
   }
-  grab_ = flags_ & kAllButtonMask;
-}
-
-void EventGenerator::ConvertPointFromTarget(const aura::Window* target,
-                                            gfx::Point* point) const {
-  DCHECK(point);
-  aura::client::ScreenPositionClient* client =
-      delegate_->GetScreenPositionClient(target);
-  if (client)
-    client->ConvertPointToScreen(target, point);
-  else
-    aura::Window::ConvertPointToTarget(target, target->GetRootWindow(), point);
-}
-
-void EventGenerator::ConvertPointToTarget(const aura::Window* target,
-                                          gfx::Point* point) const {
-  DCHECK(point);
-  aura::client::ScreenPositionClient* client =
-      delegate_->GetScreenPositionClient(target);
-  if (client)
-    client->ConvertPointFromScreen(target, point);
-  else
-    aura::Window::ConvertPointToTarget(target->GetRootWindow(), target, point);
+  grab_ = (flags_ & kAllButtonMask) != 0;
 }
 
 gfx::Point EventGenerator::GetLocationInCurrentRoot() const {
   gfx::Point p(current_location_);
-  ConvertPointToTarget(current_host_->window(), &p);
+  delegate_->ConvertPointToTarget(current_target_, &p);
   return p;
 }
 
-gfx::Point EventGenerator::CenterOfWindow(const Window* window) const {
-  gfx::Point center = gfx::Rect(window->bounds().size()).CenterPoint();
-  ConvertPointFromTarget(window, &center);
-  return center;
+gfx::Point EventGenerator::CenterOfWindow(const EventTarget* window) const {
+  return delegate_->CenterOfTarget(window);
 }
 
 void EventGenerator::DoDispatchEvent(ui::Event* event, bool async) {
   if (async) {
     ui::Event* pending_event;
     if (event->IsKeyEvent()) {
       pending_event = new ui::KeyEvent(*static_cast<ui::KeyEvent*>(event));
     } else if (event->IsMouseEvent()) {
       pending_event = new ui::MouseEvent(*static_cast<ui::MouseEvent*>(event));
     } else if (event->IsTouchEvent()) {
       pending_event = new ui::TouchEvent(*static_cast<ui::TouchEvent*>(event));
     } else if (event->IsScrollEvent()) {
       pending_event =
           new ui::ScrollEvent(*static_cast<ui::ScrollEvent*>(event));
     } else {
       NOTREACHED() << "Invalid event type";
       return;
     }
     if (pending_events_.empty()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(&EventGenerator::DispatchNextPendingEvent,
                      base::Unretained(this)));
     }
     pending_events_.push_back(pending_event);
   } else {
-    ui::EventSource* event_source = current_host_->GetEventSource();
+    ui::EventSource* event_source = delegate_->GetEventSource(current_target_);
     ui::EventSourceTestApi event_source_test(event_source);
     ui::EventDispatchDetails details =
         event_source_test.SendEventToProcessor(event);
     CHECK(!details.dispatcher_destroyed);
   }
 }
 
 void EventGenerator::DispatchNextPendingEvent() {
   DCHECK(!pending_events_.empty());
   ui::Event* event = pending_events_.front();
   DoDispatchEvent(event, false);
   pending_events_.pop_front();
   delete event;
   if (!pending_events_.empty()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&EventGenerator::DispatchNextPendingEvent,
                    base::Unretained(this)));
   }
 }
 
 }  // namespace test
-}  // namespace aura
+}  // namespace ui