Scale client area, hit test mask and bounds by device_scale_factor.

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/service_manager/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/surface_id_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/dip_util.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace ui {
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
+// Helper function to get the device_scale_factor() of the display::Display
+// with |display_id|.
+float DeviceScaleFactorForDisplay(int64_t display_id) {
+  // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after
+  // https://codereview.chromium.org/2361283002/ is landed.
+  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())
+    return iter->device_scale_factor();
+  return 1.f;
+}
+
 // Helper called to construct a local window object from transport data.
 Window* AddWindowToClient(WindowTreeClient* client,
                           Window* parent,
                           const mojom::WindowDataPtr& window_data) {
   // We don't use the ctor that takes a WindowTreeClient here, since it will
   // call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_client(client);
   private_window.set_server_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
   private_window.set_properties(
       window_data->properties
           .To<std::map<std::string, std::vector<uint8_t>>>());
   client->AddWindow(window);
-  private_window.LocalSetBounds(gfx::Rect(), window_data->bounds);
+  float device_scale_factor = DeviceScaleFactorForDisplay(window->display_id());
+  if (device_scale_factor == 1.f) {
+    private_window.LocalSetBounds(gfx::Rect(), window_data->bounds);
+  } else {
+    private_window.LocalSetBounds(
+        gfx::Rect(),
+        gfx::ConvertRectToDIP(device_scale_factor, window_data->bounds));

[sky, 2016/11/09 00:21:13]

How come you adjust bounds in the mus side, but not the aura-mus side?

[riajiang, 2016/11/09 21:07:08]

The window bounds adjustment in the mus side of WTC didn't solve all bounds
related bugs (TODOs in the CL description) so we were thinking to add bounds
conversion in aura-mus after everything works (TODO in aura::mus::WTC). Added
the adjustment here in the mus side because the conversion does need to happen
in WTC and I'm still working on finding other places where window bounds need to
be scaled.

+  }
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
   return window;
 }
 
 struct WindowTreeClient::CurrentDragState {
   // The current change id of the current drag an drop ipc.
   uint32_t change_id;
 
   // The effect to return when we send our finish signal.
@@ skipping 147 matching lines @@
   return HiWord(server_id(window)) == client_id_ &&
          roots_.count(const_cast<Window*>(window)) == 0;
 }
 
 void WindowTreeClient::SetBounds(Window* window,
                                  const gfx::Rect& old_bounds,
                                  const gfx::Rect& bounds) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightBoundsChange>(window, old_bounds));
-  tree_->SetWindowBounds(change_id, server_id(window), bounds);
+  float device_scale_factor = DeviceScaleFactorForDisplay(window->display_id());
+  if (device_scale_factor == 1.f) {
+    tree_->SetWindowBounds(change_id, server_id(window), bounds);
+  } else {
+    tree_->SetWindowBounds(
+        change_id, server_id(window),
+        gfx::ConvertRectToPixel(device_scale_factor, bounds));
+  }
 }
 
 void WindowTreeClient::SetCapture(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   if (capture_window_ == window)
     return;
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightCaptureChange>(this, capture_window_));
@@ skipping 11 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);
+  float device_scale_factor =
+      DeviceScaleFactorForDisplay(GetWindowByServerId(window_id)->display_id());
+  if (device_scale_factor == 1.f) {
+    tree_->SetClientArea(window_id, client_area, additional_client_areas);
+  } else {
+    std::vector<gfx::Rect> additional_client_areas_in_pixel;
+    for (const gfx::Rect& area : additional_client_areas) {
+      additional_client_areas_in_pixel.push_back(
+          gfx::ConvertRectToPixel(device_scale_factor, area));
+    }
+    tree_->SetClientArea(
+        window_id, gfx::ConvertInsetsToPixel(device_scale_factor, client_area),
+        additional_client_areas_in_pixel);
+  }
 }
 
 void WindowTreeClient::SetHitTestMask(Id window_id, const gfx::Rect& mask) {
   DCHECK(tree_);
-  tree_->SetHitTestMask(window_id, mask);
+  float device_scale_factor =
+      DeviceScaleFactorForDisplay(GetWindowByServerId(window_id)->display_id());
+  if (device_scale_factor == 1.f) {
+    tree_->SetHitTestMask(window_id, mask);
+  } else {
+    tree_->SetHitTestMask(window_id,
+                          gfx::ConvertRectToPixel(device_scale_factor, mask));
+  }
 }
 
 void WindowTreeClient::ClearHitTestMask(Id window_id) {
   DCHECK(tree_);
   tree_->SetHitTestMask(window_id, base::nullopt);
 }
 
 void WindowTreeClient::SetFocus(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
@@ skipping 603 matching lines @@
   DCHECK_EQ(0u, data->parent_id);
 }
 
 void WindowTreeClient::OnWindowBoundsChanged(Id window_id,
                                              const gfx::Rect& old_bounds,
                                              const gfx::Rect& new_bounds) {
   Window* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
-  InFlightBoundsChange new_change(window, new_bounds);
-  if (ApplyServerChangeToExistingInFlightChange(new_change))
-    return;
-
-  WindowPrivate(window).LocalSetBounds(old_bounds, new_bounds);
+  float device_scale_factor = DeviceScaleFactorForDisplay(window->display_id());
+  if (device_scale_factor == 1.f) {
+    InFlightBoundsChange new_change(window, new_bounds);
+    if (ApplyServerChangeToExistingInFlightChange(new_change))
+      return;
+    WindowPrivate(window).LocalSetBounds(old_bounds, new_bounds);
+  } else {
+    gfx::Rect old_bounds_in_dip =
+        gfx::ConvertRectToDIP(device_scale_factor, old_bounds);
+    gfx::Rect new_bounds_in_dip =
+        gfx::ConvertRectToDIP(device_scale_factor, new_bounds);
+    InFlightBoundsChange new_change(window, new_bounds_in_dip);
+    if (ApplyServerChangeToExistingInFlightChange(new_change))
+      return;
+    WindowPrivate(window).LocalSetBounds(old_bounds_in_dip, new_bounds_in_dip);
+  }
 }
 
 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>>());
+    float device_scale_factor =
+        DeviceScaleFactorForDisplay(window->display_id());
+    if (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> new_additional_client_areas_in_dip;
+      for (const gfx::Rect& area : new_additional_client_areas) {
+        new_additional_client_areas_in_dip.push_back(
+            gfx::ConvertRectToDIP(device_scale_factor, area));
+      }
+      WindowPrivate(window).LocalSetClientArea(
+          gfx::ConvertInsetsToDIP(device_scale_factor, new_client_area),
+          new_additional_client_areas_in_dip);
+    }
   }
 }
 
 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 362 matching lines @@
   window_manager_delegate_->OnWmDisplayModified(display);
 }
 
 void WindowTreeClient::WmSetBounds(uint32_t change_id,
                                        Id window_id,
                                        const gfx::Rect& transit_bounds) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
-    gfx::Rect bounds = transit_bounds;
+    float device_scale_factor =
+        DeviceScaleFactorForDisplay(window->display_id());
+    gfx::Rect transit_bounds_in_dip;
+    if (device_scale_factor == 1.f) {
+      transit_bounds_in_dip = transit_bounds;
+    } else {
+      transit_bounds_in_dip =
+          gfx::ConvertRectToDIP(device_scale_factor, transit_bounds);
+    }
+    gfx::Rect bounds = transit_bounds_in_dip;
     result = window_manager_delegate_->OnWmSetBounds(window, &bounds);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
-      result = bounds == transit_bounds;
+      result = bounds == transit_bounds_in_dip;
       window->SetBounds(bounds);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmSetProperty(uint32_t change_id,
                                      Id window_id,
                                      const mojo::String& name,
@@ skipping 127 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);
+    float device_scale_factor =
+        DeviceScaleFactorForDisplay(window->display_id());
+    if (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(),
+              gfx::ConvertInsetsToDIP(device_scale_factor, hit_area));
+    }
   }
 }
 
 }  // namespace ui