Keep non-key event handling in-house for NativeWidgetMus

ui/views/mus/native_widget_mus_unittest.cc

 // Copyright 2016 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/views/mus/native_widget_mus.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/tests/window_tree_client_impl_private.h"
@@ skipping 123 matching lines @@
   void GetWidgetHitTestMask(gfx::Path* mask) const override {
     mask->addRect(gfx::RectToSkRect(mask_rect_));
   }
 
  private:
   gfx::Rect mask_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetDelegateWithHitTestMask);
 };
 
+class UIMouseEventHandler : public ui::test::TestEventHandler {
+ public:
+  explicit UIMouseEventHandler(ui::PointerDetails* pointer_details)
+      : pointer_details_(pointer_details), event_received_(false) {}
+  ~UIMouseEventHandler() override {}
+
+  void OnMouseEvent(ui::MouseEvent* event) override {
+    *pointer_details_ = event->pointer_details();
+    set_event_received();
+  }
+
+  bool event_received() { return event_received_; }
+
+ private:
+  void set_event_received() { event_received_ = true; }
+
+  ui::PointerDetails* pointer_details_;
+  bool event_received_;
+
+  DISALLOW_COPY_AND_ASSIGN(UIMouseEventHandler);
+};
+
+class MusMouseEventHandler : public mus::InputEventHandler {
+ public:
+  explicit MusMouseEventHandler(ui::PointerDetails* pointer_details,
+                                    mus::Window* window)
+      : pointer_details_(pointer_details), 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());
+    *pointer_details_ = event.AsMouseEvent()->pointer_details();
+    set_event_received();
+    if (delegate_)
+      delegate_->OnWindowInputEvent(target, event, ack_callback);
+  }
+
+  ui::PointerDetails* pointer_details_;
+  mus::Window* window_;
+  bool event_received_;
+  mus::InputEventHandler* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(MusMouseEventHandler);
+};
+
 }  // namespace
 
 class NativeWidgetMusTest : public ViewsTestBase {
  public:
   NativeWidgetMusTest() {}
   ~NativeWidgetMusTest() override {}
 
   // Creates a test widget. Takes ownership of |delegate|.
   std::unique_ptr<Widget> CreateWidget(WidgetDelegate* delegate) {
     std::unique_ptr<Widget> widget(new Widget());
@@ skipping 262 matching lines @@
   content->AddPreTargetHandler(&handler);
 
   std::unique_ptr<ui::MouseEvent> mouse = CreateMouseEvent();
   NativeWidgetMus* native_widget =
       static_cast<NativeWidgetMus*>(widget->native_widget_private());
   mus::WindowTreeClientImplPrivate test_api(native_widget->window());
   test_api.CallOnWindowInputEvent(native_widget->window(), *mouse);
   EXPECT_EQ(1, handler.num_mouse_events());
 }
 
+TEST_F(NativeWidgetMusTest, WidgetViewMouseEventAgreement) {
+  std::unique_ptr<Widget> widget(CreateWidget(nullptr));
+  widget->Show();
+
+  View* content = new HandleMousePressView;
+  content->SetBounds(10, 20, 90, 180);
+  widget->GetContentsView()->AddChildView(content);
+
+  ui::PointerDetails ui_pointer_details;
+  UIMouseEventHandler ui_handler(&ui_pointer_details);
+  content->AddPreTargetHandler(&ui_handler);
+
+  ui::PointerDetails mus_pointer_details;
+  NativeWidgetMus* native_widget =
+      static_cast<NativeWidgetMus*>(widget->native_widget_private());
+  MusMouseEventHandler mus_handler(&mus_pointer_details,
+                                   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);
+
+  // Expectation: Event delivered to view and widget in same coordinate space.
+  EXPECT_TRUE(ui_handler.event_received());
+  EXPECT_TRUE(mus_handler.event_received());
+  EXPECT_EQ(ui_pointer_details, mus_pointer_details);

[sadrul, 2016/05/26 22:00:50]

PointerDetails do not contain event-location, which is the more interesting
thing to test here.

Since |content| is positioned at (10, 20), and the event is at (50, 50) on the
Widget, therefore |content| should see the event at (40, 30).

[Mark Dittmer, 2016/05/27 12:37:32]

Wait. So does that mean that the view and widget _don't_ see the same
coordinates?

[Mark Dittmer, 2016/05/27 13:46:19]

Done.

+}
+
 // Tests that an incoming UI event is acked with the handled status.
 TEST_F(NativeWidgetMusTest, EventAcked) {
   std::unique_ptr<Widget> widget(CreateWidget(nullptr));
   widget->Show();
 
   View* content = new HandleMousePressView;
   content->SetBounds(10, 20, 90, 180);
   widget->GetContentsView()->AddChildView(content);
 
   // Dispatch an input event to the window and view.
@@ skipping 81 matching lines @@
   mus_window->SetBounds(end_bounds);
 
   EXPECT_EQ(end_bounds, mus_window->bounds());
 
   // Main check for this test: Setting |mus_window| bounds while bypassing
   // |native_widget| must update window_tree_host bounds.
   EXPECT_EQ(end_bounds, native_widget->window_tree_host()->GetBounds());
 }
 
 }  // namespace views