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 25 matching lines @@
 namespace views {
 namespace {
 
 // A view that reports any mouse press as handled.
 class HandleMousePressView : public View {
  public:
   HandleMousePressView() {}
   ~HandleMousePressView() override {}
 
   // View:
-  bool OnMousePressed(const ui::MouseEvent& event) override { return true; }
+  bool OnMousePressed(const ui::MouseEvent& event) override {
+    latest_event_location_ = event.location();
+    return true;
+  }
+
+  gfx::Point latest_event_location() { return latest_event_location_; }
 
  private:
+  gfx::Point latest_event_location_;
+
   DISALLOW_COPY_AND_ASSIGN(HandleMousePressView);
 };
 
 // A view that deletes a widget on mouse press.
 class DeleteWidgetView : public View {
  public:
   explicit DeleteWidgetView(std::unique_ptr<Widget>* widget_ptr)
       : widget_ptr_(widget_ptr) {}
   ~DeleteWidgetView() override {}
 
@@ skipping 105 matching lines @@
   void AckCallback(mus::mojom::EventResult result) {
     ack_callback_count_++;
     EXPECT_EQ(mus::mojom::EventResult::HANDLED, result);
   }
 
   // Returns a mouse pressed event inside the widget. Tests that place views
   // within the widget that respond to the event must be constructed within the
   // 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));
   }
 
   // Simulates an input event to the NativeWidget.
   void OnWindowInputEvent(
       NativeWidgetMus* native_widget,
       const ui::Event& event,
       std::unique_ptr<base::Callback<void(mus::mojom::EventResult)>>*
       ack_callback) {
     native_widget->OnWindowInputEvent(native_widget->window(), event,
                                       ack_callback);
   }
 
  protected:
   gfx::Rect initial_bounds() { return gfx::Rect(10, 20, 100, 200); }
 
+  gfx::Point mouse_location() {
+    return gfx::Point(50, 50);
+  }
+
  private:
   int ack_callback_count_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(NativeWidgetMusTest);
 };
 
 // Tests communication of activation and focus between Widget and
 // NativeWidgetMus.
 TEST_F(NativeWidgetMusTest, OnActivationChanged) {
   std::unique_ptr<Widget> widget(CreateWidget(nullptr));
@@ skipping 213 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();
+
+  HandleMousePressView* content = new HandleMousePressView;
+  int content_x = 10;
+  int content_y = 20;
+  content->SetBounds(content_x, content_y, 90, 180);
+  widget->GetContentsView()->AddChildView(content);
+
+  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);
+
+  // 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),
+            content->latest_event_location());
+}
+
 // 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