Keep non-key event handling in-house for NativeWidgetMus

ui/views/mus/native_widget_mus_unittest.cc

Index: ui/views/mus/native_widget_mus_unittest.cc
diff --git a/ui/views/mus/native_widget_mus_unittest.cc b/ui/views/mus/native_widget_mus_unittest.cc
index a460a4d6fb757042a86315ea19f37fec450bc273..b1ac9c0b276ec4cba465ff862bbe75e4b31e7acf 100644
--- a/ui/views/mus/native_widget_mus_unittest.cc
+++ b/ui/views/mus/native_widget_mus_unittest.cc
@@ -141,6 +141,66 @@ class WidgetDelegateWithHitTestMask : public WidgetDelegateView {
   DISALLOW_COPY_AND_ASSIGN(WidgetDelegateWithHitTestMask);
 };
 
+class UIMouseEventHandler : public ui::test::TestEventHandler {
+ public:
+  explicit UIMouseEventHandler(gfx::Point* event_location)
+      : event_location_(event_location), event_received_(false) {}
+  ~UIMouseEventHandler() override {}
+
+  void OnMouseEvent(ui::MouseEvent* event) override {
+    *event_location_ = event->location();
+    set_event_received();
+  }
+
+  bool event_received() { return event_received_; }
+
+ private:
+  void set_event_received() { event_received_ = true; }
+
+  gfx::Point* event_location_;
+  bool event_received_;
+
+  DISALLOW_COPY_AND_ASSIGN(UIMouseEventHandler);
+};
+
+class MusMouseEventHandler : public mus::InputEventHandler {
+ public:
+  MusMouseEventHandler(gfx::Point* event_location, mus::Window* window)
+      : event_location_(event_location), window_(window),
+        event_received_(false) {
+    delegate_ = window->input_event_handler();
+    window->set_input_event_handler(this);
+  }
+  ~MusMouseEventHandler() override {
+    window_->set_input_event_handler(delegate_);
+  }
+
+  bool event_received() { return event_received_; }
+
+ private:
+  void set_event_received() { event_received_ = true; }
+
+  // InputEventHandler:
+  void OnWindowInputEvent(
+      mus::Window* target,
+      const ui::Event& event,
+      std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback)
+      override {
+    DCHECK(event.IsMouseEvent());
+    *event_location_ = event.AsMouseEvent()->location();
+    set_event_received();
+    if (delegate_)
+      delegate_->OnWindowInputEvent(target, event, ack_callback);
+  }
+
+  gfx::Point* event_location_;
+  mus::Window* window_;
+  bool event_received_;
+  mus::InputEventHandler* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(MusMouseEventHandler);
+};
+
 }  // namespace
 
 class NativeWidgetMusTest : public ViewsTestBase {
@@ -171,7 +231,7 @@ class NativeWidgetMusTest : public ViewsTestBase {
   // widget coordinate space such that they respond correctly.
   std::unique_ptr<ui::MouseEvent> CreateMouseEvent() {
     return base::WrapUnique(new ui::MouseEvent(
-        ui::ET_MOUSE_PRESSED, gfx::Point(50, 50), gfx::Point(50, 50),
+        ui::ET_MOUSE_PRESSED, mouse_location(), mouse_location(),
         base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
   }
 
@@ -190,6 +250,10 @@ class NativeWidgetMusTest : public ViewsTestBase {
     return gfx::Rect(10, 20, 100, 200);
   }
 
+  gfx::Point mouse_location() {
+    return gfx::Point(50, 50);
+  }
+
  private:
   int ack_callback_count_ = 0;
 
@@ -423,6 +487,39 @@ TEST_F(NativeWidgetMusTest, WidgetReceivesEvent) {
   EXPECT_EQ(1, handler.num_mouse_events());
 }
 
+TEST_F(NativeWidgetMusTest, WidgetViewMouseEventAgreement) {
+  std::unique_ptr<Widget> widget(CreateWidget(nullptr));
+  widget->Show();
+
+  View* content = new HandleMousePressView;
+  int content_x = 10;
+  int content_y = 20;
+  content->SetBounds(content_x, content_y, 90, 180);
+  widget->GetContentsView()->AddChildView(content);
+
+  gfx::Point ui_event_location;
+  UIMouseEventHandler ui_handler(&ui_event_location);
+  content->AddPreTargetHandler(&ui_handler);
+
+  gfx::Point mus_event_location;
+  NativeWidgetMus* native_widget =
+      static_cast<NativeWidgetMus*>(widget->native_widget_private());
+  MusMouseEventHandler mus_handler(&mus_event_location,
+                                   native_widget->window());  // Self-installed.
+
+  std::unique_ptr<ui::MouseEvent> mouse = CreateMouseEvent();
+  mus::WindowTreeClientImplPrivate test_api(native_widget->window());
+  test_api.CallOnWindowInputEvent(native_widget->window(), *mouse);
+
+  EXPECT_TRUE(ui_handler.event_received());
+  EXPECT_TRUE(mus_handler.event_received());
+  // Location delivered to view should be relative to view's origin.
+  EXPECT_EQ(gfx::Point(mouse_location().x() - content_x,
+                       mouse_location().y() - content_y),
+            ui_event_location);
+  EXPECT_EQ(gfx::Point(mouse_location()), mus_event_location);

[sadrul, 2016/05/27 18:11:16]

I think this test could be simpler:

  . Define an EventView that keeps track of the events it received and their
locations.
  . Add that EventView to the Widget.
  . Use WindowTreeClientImplPrivate to drop the event on the mus::Window.
  . Get the event-location from EventView, verify that it is correct.

I don't think we need either UIMouseEventHandler, or MusMouseEventHandler.

[Mark Dittmer, 2016/05/30 17:03:59]

Done.

+}
+
 // Tests that an incoming UI event is acked with the handled status.
 TEST_F(NativeWidgetMusTest, EventAcked) {
   std::unique_ptr<Widget> widget(CreateWidget(nullptr));