Fix event dispatching and window resizing in high-dpi mode.

services/ui/public/cpp/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 "services/ui/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/ui/common/util.h"
 #include "services/ui/public/cpp/in_flight_change.h"
 #include "services/ui/public/cpp/input_event_handler.h"
 #include "services/ui/public/cpp/window_drop_target.h"
 #include "services/ui/public/cpp/window_manager_delegate.h"
 #include "services/ui/public/cpp/window_observer.h"
 #include "services/ui/public/cpp/window_private.h"
 #include "services/ui/public/cpp/window_tracker.h"
 #include "services/ui/public/cpp/window_tree_client_delegate.h"
 #include "services/ui/public/cpp/window_tree_client_observer.h"
 #include "services/ui/public/interfaces/window_manager_window_tree_factory.mojom.h"
+#include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace ui {
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
 // Helper called to construct a local window object from transport data.
 Window* AddWindowToClient(WindowTreeClient* client,
                           Window* parent,
@@ skipping 201 matching lines @@
       base::MakeUnique<InFlightCaptureChange>(this, window));
   tree_->ReleaseCapture(change_id, server_id(window));
   LocalSetCapture(nullptr);
 }
 
 void WindowTreeClient::SetClientArea(
     Id window_id,
     const gfx::Insets& client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   DCHECK(tree_);
-  tree_->SetClientArea(window_id, client_area, additional_client_areas);
+  Window* window = GetWindowByServerId(window_id);
+  // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after
+  // https://codereview.chromium.org/2361283002/ is landed.
+  int64_t display_id = window->display_id();
+  std::vector<display::Display> displays =
+      display::Screen::GetScreen()->GetAllDisplays();
+  auto iter = std::find_if(displays.begin(), displays.end(),
+                           [display_id](const display::Display& display) {
+                             return display.id() == display_id;
+                           });
+  if (iter != displays.end()) {
+    if (iter->device_scale_factor() == 1.f) {
+      tree_->SetClientArea(window_id, client_area, additional_client_areas);
+    } else {
+      std::vector<gfx::Rect> scaled_additional_client_areas;
+      for (const gfx::Rect& area : additional_client_areas) {
+        scaled_additional_client_areas.push_back(
+            gfx::ScaleToEnclosingRect(area, iter->device_scale_factor()));
+      }
+      tree_->SetClientArea(window_id,
+                           client_area.Scale(iter->device_scale_factor()),
+                           scaled_additional_client_areas);
+    }
+  }
 }
 
 void WindowTreeClient::SetHitTestMask(Id window_id, const gfx::Rect& mask) {
   DCHECK(tree_);
   tree_->SetHitTestMask(window_id, mask);
 }
 
 void WindowTreeClient::ClearHitTestMask(Id window_id) {
   DCHECK(tree_);
   tree_->SetHitTestMask(window_id, base::nullopt);
@@ skipping 622 matching lines @@
 
   WindowPrivate(window).LocalSetBounds(old_bounds, new_bounds);
 }
 
 void WindowTreeClient::OnClientAreaChanged(
     uint32_t window_id,
     const gfx::Insets& new_client_area,
     mojo::Array<gfx::Rect> new_additional_client_areas) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
-    WindowPrivate(window).LocalSetClientArea(
-        new_client_area,
-        new_additional_client_areas.To<std::vector<gfx::Rect>>());
+    // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after

[sky, 2016/10/06 16:38:13]

You could at least make this code use a common function.

[riajiang, 2016/10/06 19:33:03]

Yes! Done.

+    // https://codereview.chromium.org/2361283002/ is landed.
+    int64_t display_id = window->display_id();
+    std::vector<display::Display> displays =
+        display::Screen::GetScreen()->GetAllDisplays();
+    auto iter = std::find_if(displays.begin(), displays.end(),
+                             [display_id](const display::Display& display) {
+                               return display.id() == display_id;
+                             });
+    if (iter != displays.end()) {
+      if (iter->device_scale_factor() == 1.f) {
+        WindowPrivate(window).LocalSetClientArea(
+            new_client_area,
+            new_additional_client_areas.To<std::vector<gfx::Rect>>());
+      } else {
+        std::vector<gfx::Rect> scaled_new_additional_client_areas;
+        for (const gfx::Rect& area : new_additional_client_areas) {
+          scaled_new_additional_client_areas.push_back(
+              gfx::ScaleToEnclosingRect(area,
+                                        1.f / iter->device_scale_factor()));
+        }
+        WindowPrivate(window).LocalSetClientArea(
+            new_client_area.Scale(1.f / iter->device_scale_factor()),
+            scaled_new_additional_client_areas);
+      }
+    }
   }
 }
 
 void WindowTreeClient::OnTransientWindowAdded(
     uint32_t window_id,
     uint32_t transient_window_id) {
   Window* window = GetWindowByServerId(window_id);
   Window* transient_window = GetWindowByServerId(transient_window_id);
   // window or transient_window or both may be null if a local delete occurs
   // with an in flight add from the server.
@@ skipping 493 matching lines @@
 void WindowTreeClient::ActivateNextWindow() {
   if (window_manager_internal_client_)
     window_manager_internal_client_->ActivateNextWindow();
 }
 
 void WindowTreeClient::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
-    window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
-        server_id(window), offset.x(), offset.y(), hit_area);
+    // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after
+    // https://codereview.chromium.org/2361283002/ is landed.
+    int64_t display_id = window->display_id();
+    std::vector<display::Display> displays =
+        display::Screen::GetScreen()->GetAllDisplays();
+    auto iter = std::find_if(displays.begin(), displays.end(),
+                             [display_id](const display::Display& display) {
+                               return display.id() == display_id;
+                             });
+    if (iter != displays.end()) {
+      if (iter->device_scale_factor() == 1.f) {
+        window_manager_internal_client_
+            ->SetUnderlaySurfaceOffsetAndExtendedHitArea(
+                server_id(window), offset.x(), offset.y(), hit_area);
+      } else {
+        window_manager_internal_client_
+            ->SetUnderlaySurfaceOffsetAndExtendedHitArea(
+                server_id(window), offset.x(), offset.y(),
+                hit_area.Scale(1.f / iter->device_scale_factor()));
+      }
+    }
   }
 }
 
 }  // namespace ui