chromeos: converts observed pointer events to DIPs

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 127 matching lines @@
 }
 
 // Helper function to get the device_scale_factor() of the display::Display
 // nearest to |window|.
 float ScaleFactorForDisplay(Window* window) {
   return display::Screen::GetScreen()
       ->GetDisplayNearestWindow(window)
       .device_scale_factor();
 }
 
+void ConvertEventLocationToDip(int64_t display_id, ui::LocatedEvent* event) {
+  display::Screen* screen = display::Screen::GetScreen();
+  display::Display display;
+  if (!screen->GetDisplayWithDisplayId(display_id, &display) ||
+      display.device_scale_factor() == 1.f) {
+    return;
+  }
+  const gfx::Point host_location =
+      gfx::ConvertPointToDIP(display.device_scale_factor(), event->location());
+  event->set_location(host_location);
+  const gfx::Point root_location = gfx::ConvertPointToDIP(
+      display.device_scale_factor(), event->root_location());
+  event->set_root_location(root_location);
+}
+
 }  // namespace
 
 WindowTreeClient::WindowTreeClient(
     service_manager::Connector* connector,
     WindowTreeClientDelegate* delegate,
     WindowManagerDelegate* window_manager_delegate,
     mojo::InterfaceRequest<ui::mojom::WindowTreeClient> request,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : connector_(connector),
       client_id_(0),
@@ skipping 949 matching lines @@
   InFlightPropertyChange new_change(window, name, std::move(data));
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   window->SetPropertyFromServer(
       name, transport_data.has_value() ? &transport_data.value() : nullptr);
 }
 
 void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
                                           Id window_id,
+                                          int64_t display_id,
                                           std::unique_ptr<ui::Event> event,
                                           bool matches_pointer_watcher) {
   DCHECK(event);
 
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
   if (event->IsKeyEvent()) {
     DCHECK(!matches_pointer_watcher);  // PointerWatcher isn't for key events.
     if (!window || !window->GetWindow()->GetHost()) {
       tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
       return;
     }
     InputMethodMus* input_method = GetWindowTreeHostMus(window)->input_method();
     input_method->DispatchKeyEvent(event->AsKeyEvent(),
                                    CreateEventResultCallback(event_id));
     return;
   }
 
   if (matches_pointer_watcher && has_pointer_watcher_) {
     DCHECK(event->IsPointerEvent());
-    delegate_->OnPointerEventObserved(*event->AsPointerEvent(),
+    std::unique_ptr<ui::Event> event_in_dip(ui::Event::Clone(*event));
+    ConvertEventLocationToDip(display_id, event_in_dip->AsLocatedEvent());
+    delegate_->OnPointerEventObserved(*event_in_dip->AsPointerEvent(),
                                       window ? window->GetWindow() : nullptr);
   }
 
-  // TODO: deal with no window or host here. This could happen if during
-  // dispatch a window is deleted or moved. In either case we still need to
-  // dispatch. Most likely need the display id.
+  // TODO: use |display_id| to find host and send there.
   if (!window || !window->GetWindow()->GetHost()) {
     tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
     return;
   }
 
   WindowTreeHostMus* host = GetWindowTreeHostMus(window);
   DCHECK(host);
 
   // The location of the event is relative to |window|. As the event is handed
   // to WindowTreeHost we need it to be relative to WindowTreeHost.
@@ skipping 18 matching lines @@
   } else if (event->IsTouchPointerEvent()) {
     ui::TouchEvent mapped_event(*event->AsPointerEvent());
     host->SendEventToProcessor(&mapped_event);
   } else {
     host->SendEventToProcessor(event.get());
   }
   ack_handler.set_handled(event->handled());
 }
 
 void WindowTreeClient::OnPointerEventObserved(std::unique_ptr<ui::Event> event,
-                                              uint32_t window_id) {
+                                              uint32_t window_id,
+                                              int64_t display_id) {
   DCHECK(event);
   DCHECK(event->IsPointerEvent());
   if (!has_pointer_watcher_)
     return;
 
+  ConvertEventLocationToDip(display_id, event->AsLocatedEvent());
   WindowMus* target_window = GetWindowByServerId(window_id);
   delegate_->OnPointerEventObserved(
       *event->AsPointerEvent(),
       target_window ? target_window->GetWindow() : nullptr);
 }
 
 void WindowTreeClient::OnWindowFocused(Id focused_window_id) {
   WindowMus* focused_window = GetWindowByServerId(focused_window_id);
   InFlightFocusChange new_change(this, focus_synchronizer_.get(),
                                  focused_window);
@@ skipping 620 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura