ozone/platform/wayland: Implement pointer handling

ui/ozone/platform/wayland/wayland_window_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 <wayland-server-core.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
 
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event.h"
 #include "ui/ozone/platform/wayland/fake_server.h"
 #include "ui/ozone/platform/wayland/mock_platform_window_delegate.h"
 #include "ui/ozone/platform/wayland/wayland_display.h"
 #include "ui/ozone/platform/wayland/wayland_window.h"
 
 using ::testing::Eq;
 using ::testing::Mock;
 using ::testing::SaveArg;
 using ::testing::StrEq;
 using ::testing::_;
@@ skipping 16 matching lines @@
 
   server.Pause();
 
   EXPECT_TRUE(server.GetObject<wl::MockSurface>(window.GetWidget()));
   server.Resume();
 }
 
 class WaylandWindowTest : public testing::Test {
  public:
   WaylandWindowTest()
-      : window(&delegate, &display, gfx::Rect(0, 0, 800, 600)) {}
+      : window(&delegate, &display, gfx::Rect(0, 0, 800, 600)),
+        test_mouse_event(ET_MOUSE_PRESSED,
+                         gfx::Point(10, 15),
+                         gfx::Point(10, 15),
+                         base::TimeDelta::FromSeconds(123456),
+                         EF_LEFT_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON,
+                         EF_LEFT_MOUSE_BUTTON) {}
 
   void SetUp() override {
     ASSERT_TRUE(server.Start());
     ASSERT_TRUE(display.Initialize());
     ASSERT_TRUE(window.Initialize());
     wl_display_roundtrip(display.display());
 
     server.Pause();
 
     auto surface = server.GetObject<wl::MockSurface>(window.GetWidget());
@@ skipping 14 matching lines @@
     wl_display_roundtrip(display.display());
     server.Pause();
   }
 
  private:
   wl::FakeServer server;
   bool initialized = false;
 
  protected:
   WaylandDisplay display;
-
   MockPlatformWindowDelegate delegate;
   WaylandWindow window;
 
   wl::MockXdgSurface* xdg_surface;
 
+  MouseEvent test_mouse_event;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(WaylandWindowTest);
 };
 
 TEST_F(WaylandWindowTest, SetTitle) {
   EXPECT_CALL(*xdg_surface, SetTitle(StrEq("hello")));
   window.SetTitle(base::ASCIIToUTF16("hello"));
 }
 
 TEST_F(WaylandWindowTest, Maximize) {
   EXPECT_CALL(*xdg_surface, SetMaximized());
   window.Maximize();
 }
 
 TEST_F(WaylandWindowTest, Minimize) {
   EXPECT_CALL(*xdg_surface, SetMinimized());
   window.Minimize();
 }
 
 TEST_F(WaylandWindowTest, Restore) {
   EXPECT_CALL(*xdg_surface, UnsetMaximized());
   window.Restore();
 }
 
+TEST_F(WaylandWindowTest, CanDispatchMouseEventDefault) {
+  EXPECT_FALSE(window.CanDispatchEvent(&test_mouse_event));
+}
+
+TEST_F(WaylandWindowTest, CanDispatchMouseEventFocus) {
+  window.set_pointer_focus(true);
+  EXPECT_TRUE(window.CanDispatchEvent(&test_mouse_event));
+}
+
+TEST_F(WaylandWindowTest, CanDispatchMouseEventUnfocus) {
+  window.set_pointer_focus(false);
+  EXPECT_FALSE(window.CanDispatchEvent(&test_mouse_event));
+}
+
+ACTION_P(CloneEvent, ptr) {
+  *ptr = Event::Clone(*arg0);
+}
+
+TEST_F(WaylandWindowTest, DispatchEvent) {
+  scoped_ptr<Event> event;
+  EXPECT_CALL(delegate, DispatchEvent(_)).WillOnce(CloneEvent(&event));
+  window.DispatchEvent(&test_mouse_event);
+  ASSERT_TRUE(event);
+  ASSERT_TRUE(event->IsMouseEvent());
+  auto mouse_event = static_cast<MouseEvent*>(event.get());
+  EXPECT_EQ(mouse_event->location_f(), test_mouse_event.location_f());
+  EXPECT_EQ(mouse_event->root_location_f(), test_mouse_event.root_location_f());
+  EXPECT_EQ(mouse_event->time_stamp(), test_mouse_event.time_stamp());
+  EXPECT_EQ(mouse_event->button_flags(), test_mouse_event.button_flags());
+  EXPECT_EQ(mouse_event->changed_button_flags(),
+            test_mouse_event.changed_button_flags());
+}
+
 TEST_F(WaylandWindowTest, ConfigureEvent) {
   wl_array states;
   wl_array_init(&states);
   xdg_surface_send_configure(xdg_surface->resource(), 1000, 1000, &states, 12);
   xdg_surface_send_configure(xdg_surface->resource(), 1500, 1000, &states, 13);
 
   // Make sure that the implementation does not call OnBoundsChanged for each
   // configure event if it receives multiple in a row.
   EXPECT_CALL(delegate, OnBoundsChanged(_)).Times(0);
   Sync();
   Mock::VerifyAndClearExpectations(&delegate);
 
   EXPECT_CALL(delegate, OnBoundsChanged(Eq(gfx::Rect(0, 0, 1500, 1000))));
   EXPECT_CALL(*xdg_surface, AckConfigure(13));
   window.ApplyPendingBounds();
 }
 
 }  // namespace ui