chromeos: converts observed pointer events to DIPs

ui/aura/mus/window_tree_client_unittest.cc

 // Copyright 2015 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/mus/window_tree_client.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/compositor/compositor.h"
+#include "ui/display/display.h"
 #include "ui/display/display_switches.h"
+#include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace aura {
 
 namespace {
 
 DEFINE_UI_CLASS_PROPERTY_KEY(uint8_t, kTestPropertyKey1, 0);
 DEFINE_UI_CLASS_PROPERTY_KEY(uint16_t, kTestPropertyKey2, 0);
 DEFINE_UI_CLASS_PROPERTY_KEY(bool, kTestPropertyKey3, false);
 
@@ skipping 50 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientWmTestHighDPI);
 };
 
 // WindowTreeClientClientTest with --force-device-scale-factor=2.
 class WindowTreeClientClientTestHighDPI : public WindowTreeClientClientTest {
  public:
   WindowTreeClientClientTestHighDPI() {}
   ~WindowTreeClientClientTestHighDPI() override {}
 
+  const ui::PointerEvent* last_event_observed() const {
+    return last_event_observed_.get();
+  }
+
   // WindowTreeClientClientTest:
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kForceDeviceScaleFactor, "2");
     WindowTreeClientClientTest::SetUp();
   }
+  void OnPointerEventObserved(const ui::PointerEvent& event,
+                              Window* target) override {
+    last_event_observed_.reset(new ui::PointerEvent(event));
+  }
 
  private:
+  std::unique_ptr<ui::PointerEvent> last_event_observed_;
   DISALLOW_COPY_AND_ASSIGN(WindowTreeClientClientTestHighDPI);
 };
 
 // Verifies bounds are reverted if the server replied that the change failed.
 TEST_F(WindowTreeClientWmTest, SetBoundsFailed) {
   Window window(nullptr);
   window.Init(ui::LAYER_NOT_DRAWN);
   const gfx::Rect original_bounds(window.bounds());
   const gfx::Rect new_bounds(gfx::Rect(0, 0, 100, 100));
   ASSERT_NE(new_bounds, window.bounds());
@@ skipping 397 matching lines @@
   child.SetBounds(gfx::Rect(10, 10, 100, 100));
   child.Show();
   EXPECT_FALSE(window_delegate.got_move());
   EXPECT_FALSE(window_delegate.was_acked());
   const gfx::Point event_location_in_child(2, 3);
   std::unique_ptr<ui::Event> ui_event(
       new ui::MouseEvent(ui::ET_MOUSE_MOVED, event_location_in_child,
                          gfx::Point(), ui::EventTimeForNow(), ui::EF_NONE, 0));
   window_tree_client()->OnWindowInputEvent(
       InputEventBasicTestWindowDelegate::kEventId, server_id(&child),
-      ui::Event::Clone(*ui_event.get()), 0);
+      window_tree_host.display_id(), ui::Event::Clone(*ui_event.get()), 0);
   EXPECT_TRUE(window_tree()->WasEventAcked(
       InputEventBasicTestWindowDelegate::kEventId));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(
                 InputEventBasicTestWindowDelegate::kEventId));
   EXPECT_TRUE(window_delegate.got_move());
   EXPECT_FALSE(window_delegate.was_acked());
   EXPECT_EQ(event_location_in_child, window_delegate.last_event_location());
 }
 
@@ skipping 30 matching lines @@
 
   // Start a pointer watcher for all events excluding move events.
   window_tree_client_impl()->StartPointerWatcher(false /* want_moves */);
 
   // Simulate the server sending an observed event.
   std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
       ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
       0, ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
       base::TimeTicks()));
   window_tree_client()->OnPointerEventObserved(std::move(pointer_event_down),
-                                               0u);
+                                               0u, 0);
 
   // Delegate sensed the event.
   const ui::PointerEvent* last_event = last_event_observed();
   ASSERT_TRUE(last_event);
   EXPECT_EQ(ui::ET_POINTER_DOWN, last_event->type());
   EXPECT_EQ(ui::EF_CONTROL_DOWN, last_event->flags());
   DeleteLastEventObserved();
 
   // Stop the pointer watcher.
   window_tree_client_impl()->StopPointerWatcher();
 
   // Simulate another event from the server.
   std::unique_ptr<ui::PointerEvent> pointer_event_up(new ui::PointerEvent(
       ui::ET_POINTER_UP, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1, 0,
       ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
       base::TimeTicks()));
-  window_tree_client()->OnPointerEventObserved(std::move(pointer_event_up), 0u);
+  window_tree_client()->OnPointerEventObserved(std::move(pointer_event_up), 0u,
+                                               0);
 
   // No event was sensed.
   EXPECT_FALSE(last_event_observed());
 }
 
 // Tests pointer watchers triggered by events that hit this window tree.
 TEST_F(WindowTreeClientPointerObserverTest,
        OnWindowInputEventWithPointerWatcher) {
   std::unique_ptr<Window> top_level(base::MakeUnique<Window>(nullptr));
   top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
   top_level->Init(ui::LAYER_NOT_DRAWN);
   top_level->SetBounds(gfx::Rect(0, 0, 100, 100));
   top_level->Show();
 
   // Start a pointer watcher for all events excluding move events.
   window_tree_client_impl()->StartPointerWatcher(false /* want_moves */);
 
   // Simulate the server dispatching an event that also matched the observer.
   std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
       ui::ET_POINTER_DOWN, gfx::Point(), gfx::Point(), ui::EF_CONTROL_DOWN, 1,
       0, ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
       base::TimeTicks::Now()));
-  window_tree_client()->OnWindowInputEvent(1, server_id(top_level.get()),
+  window_tree_client()->OnWindowInputEvent(1, server_id(top_level.get()), 0,
                                            std::move(pointer_event_down), true);
 
   // Delegate sensed the event.
   const ui::Event* last_event = last_event_observed();
   ASSERT_TRUE(last_event);
   EXPECT_EQ(ui::ET_POINTER_DOWN, last_event->type());
   EXPECT_EQ(ui::EF_CONTROL_DOWN, last_event->flags());
 }
 
 // Verifies focus is reverted if the server replied that the change failed.
@@ skipping 929 matching lines @@
       WindowTreeChangeType::NEW_TOP_LEVEL, &change_id));
   window_tree_client()->OnTopLevelCreated(change_id, std::move(data),
                                           display_id, true);
 
   // aura::Window should operate in DIP and aura::WindowTreeHost should operate
   // in pixels.
   EXPECT_EQ(gfx::Rect(0, 0, 3, 4), top_level->bounds());
   EXPECT_EQ(gfx::Rect(2, 4, 6, 8), top_level->GetHost()->GetBoundsInPixels());
 }
 
+TEST_F(WindowTreeClientClientTestHighDPI, PointerEventsInDips) {
+  display::Screen* screen = display::Screen::GetScreen();
+  const display::Display primary_display = screen->GetPrimaryDisplay();
+  ASSERT_EQ(2.0f, primary_display.device_scale_factor());
+
+  std::unique_ptr<Window> top_level(base::MakeUnique<Window>(nullptr));
+  top_level->SetType(ui::wm::WINDOW_TYPE_NORMAL);
+  top_level->Init(ui::LAYER_NOT_DRAWN);
+  top_level->SetBounds(gfx::Rect(0, 0, 100, 100));
+  top_level->Show();
+
+  // Start a pointer watcher for all events excluding move events.
+  window_tree_client_impl()->StartPointerWatcher(false /* want_moves */);
+
+  // Simulate the server sending an observed event.
+  const gfx::Point location_pixels(10, 12);
+  const gfx::Point root_location_pixels(14, 16);
+  std::unique_ptr<ui::PointerEvent> pointer_event_down(new ui::PointerEvent(
+      ui::ET_POINTER_DOWN, location_pixels, root_location_pixels,
+      ui::EF_CONTROL_DOWN, 1, 0,
+      ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_TOUCH),
+      base::TimeTicks()));
+  window_tree_client()->OnPointerEventObserved(std::move(pointer_event_down),
+                                               0u, primary_display.id());
+
+  // Delegate received the event in Dips.
+  const ui::PointerEvent* last_event = last_event_observed();
+  ASSERT_TRUE(last_event);
+  EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, location_pixels),
+            last_event->location());
+  EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, root_location_pixels),
+            last_event->root_location());
+}
+
 }  // namespace aura