Scale bounds in aura-mus client-lib and NativeWidgetMus in hdpi mode.

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 116 matching lines @@
   if (type_iter == properties.end())
     return;
 
   // TODO: need to validate type! http://crbug.com/654924.
   ui::mojom::WindowType window_type = static_cast<ui::mojom::WindowType>(
       mojo::ConvertTo<int32_t>(type_iter->second));
   SetWindowType(window, window_type);
 }
 
 // Helper function to get the device_scale_factor() of the display::Display
-// with |display_id|.
+// nearest to |window|.
 float ScaleFactorForDisplay(Window* window) {
-  // TODO(riajiang): Change to use display::GetDisplayWithDisplayId() after
-  // https://codereview.chromium.org/2361283002/ is landed.
   return display::Screen::GetScreen()
       ->GetDisplayNearestWindow(window)
       .device_scale_factor();
 }
 
 }  // namespace
 
 WindowTreeClient::WindowTreeClient(
     service_manager::Connector* connector,
     WindowTreeClientDelegate* delegate,
@@ skipping 268 matching lines @@
     const ui::mojom::WindowData& window_data) {
   // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data, WindowMusType::OTHER));
   WindowPortMus* window_port_mus_ptr = window_port_mus.get();
   Window* window = new Window(nullptr, std::move(window_port_mus));
   WindowMus* window_mus = window_port_mus_ptr;
   SetWindowTypeFromProperties(window, window_data.properties);
   window->Init(ui::LAYER_NOT_DRAWN);
   SetLocalPropertiesFromServerProperties(window_mus, window_data);
-  window_mus->SetBoundsFromServer(window_data.bounds);
+  window_mus->SetBoundsFromServer(
+      gfx::ConvertRectToDIP(ScaleFactorForDisplay(window), window_data.bounds));
   if (parent)
     parent->AddChildFromServer(window_port_mus_ptr);
   if (window_data.visible)
     window_mus->SetVisibleFromServer(true);
   return window_port_mus_ptr;
 }
 
 void WindowTreeClient::SetWindowTree(ui::mojom::WindowTreePtr window_tree_ptr) {
   tree_ptr_ = std::move(window_tree_ptr);
   WindowTreeConnectionEstablished(tree_ptr_.get());
@@ skipping 90 matching lines @@
 }
 
 void WindowTreeClient::OnReceivedCursorLocationMemory(
     mojo::ScopedSharedBufferHandle handle) {
   cursor_location_mapping_ = handle->Map(sizeof(base::subtle::Atomic32));
   DCHECK(cursor_location_mapping_);
 }
 
 void WindowTreeClient::SetWindowBoundsFromServer(
     WindowMus* window,
     const gfx::Rect& revert_bounds) {

[sadrul, 2016/12/21 16:22:44]

Let's call this revert_bounds_in_pixels

[riajiang, 2016/12/21 17:48:33]

Done.

   if (IsRoot(window)) {
     GetWindowTreeHostMus(window)->SetBoundsFromServer(revert_bounds);

[sadrul, 2016/12/21 16:22:44]

Add a comment here that WindowTreeHost expects bounds to be in pixels.

[riajiang, 2016/12/21 17:48:32]

Done.

     return;
   }
 
-  window->SetBoundsFromServer(revert_bounds);
+  window->SetBoundsFromServer(gfx::ConvertRectToDIP(
+      ScaleFactorForDisplay(window->GetWindow()), revert_bounds));
 }
 
 void WindowTreeClient::SetWindowVisibleFromServer(WindowMus* window,
                                                   bool visible) {
   if (!IsRoot(window)) {
     window->SetVisibleFromServer(visible);
     return;
   }
 
   std::unique_ptr<WindowMusChangeData> data =
@@ skipping 84 matching lines @@
 
 void WindowTreeClient::OnWindowMusBoundsChanged(WindowMus* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
   // Changes to bounds of root windows are routed through
   // OnWindowTreeHostBoundsWillChange(). Any bounds that happen here are a side
   // effect of those and can be ignored.
   if (IsRoot(window))
     return;
 
-  ScheduleInFlightBoundsChange(window, old_bounds, new_bounds);
+  ScheduleInFlightBoundsChange(

[sadrul, 2016/12/21 16:22:44]

  float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());

then use that for the conversions below.

[riajiang, 2016/12/21 17:48:33]

Done.

+      window, gfx::ConvertRectToPixel(
+                  ScaleFactorForDisplay(window->GetWindow()), old_bounds),
+      gfx::ConvertRectToPixel(ScaleFactorForDisplay(window->GetWindow()),
+                              new_bounds));
 }
 
 void WindowTreeClient::OnWindowMusAddChild(WindowMus* parent,
                                            WindowMus* child) {
   // TODO: add checks to ensure this can work.
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<CrashInFlightChange>(parent, ChangeType::ADD_CHILD));
   tree_->AddWindow(change_id, parent->server_id(), child->server_id());
 }
 
@@ skipping 256 matching lines @@
       SetWindowVisibleFromServer(window, true);
   }
 
   const gfx::Rect bounds(data->bounds);
   {
     InFlightBoundsChange bounds_change(this, window, bounds);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
-    else if (window->GetWindow()->bounds() != bounds)
+    else if (gfx::ConvertRectToPixel(ScaleFactorForDisplay(window->GetWindow()),
+                                     window->GetWindow()->bounds()) != bounds)
       SetWindowBoundsFromServer(window, bounds);
   }
 
   // There is currently no API to bulk set properties, so we iterate over each
   // property individually.
   for (const auto& pair : data->properties) {
     std::unique_ptr<std::vector<uint8_t>> revert_value(
         base::MakeUnique<std::vector<uint8_t>>(pair.second));
     InFlightPropertyChange property_change(window, pair.first,
                                            std::move(revert_value));
@@ skipping 401 matching lines @@
     }
   }
 }
 
 void WindowTreeClient::WmDisplayModified(const display::Display& display) {
   DCHECK(window_manager_delegate_);
   // TODO(sky): this should likely route to WindowTreeHost.
   window_manager_delegate_->OnWmDisplayModified(display);
 }
 
-// TODO(riajiang): Convert between pixel and DIP for window bounds properly.
-// (http://crbug.com/646942)
 void WindowTreeClient::WmSetBounds(uint32_t change_id,
                                    Id window_id,
-                                   const gfx::Rect& transit_bounds) {
+                                   const gfx::Rect& transit_bounds_in_pixels) {
   WindowMus* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
+    float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());
     DCHECK(window_manager_delegate_);
-    gfx::Rect bounds = transit_bounds;
+    gfx::Rect transit_bounds_in_dip =
+        gfx::ConvertRectToDIP(device_scale_factor, transit_bounds_in_pixels);
+    gfx::Rect bounds_in_dip = transit_bounds_in_dip;
     // TODO: this needs to trigger scheduling a bounds change on |window|.
-    result =
-        window_manager_delegate_->OnWmSetBounds(window->GetWindow(), &bounds);
+    result = window_manager_delegate_->OnWmSetBounds(window->GetWindow(),
+                                                     &bounds_in_dip);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
-      result = bounds == transit_bounds;
-      window->SetBoundsFromServer(bounds);
+      result = bounds_in_dip == transit_bounds_in_dip;
+      window->SetBoundsFromServer(bounds_in_dip);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClient::WmSetProperty(
     uint32_t change_id,
     Id window_id,
     const std::string& name,
@@ skipping 143 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_) {
-    // TODO(riajiang): Figure out if |offset| needs to be converted.
-    // (http://crbugs.com/646932)
+    float device_scale_factor = ScaleFactorForDisplay(window);
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
-        WindowMus::Get(window)->server_id(), offset.x(), offset.y(),
-        gfx::ConvertInsetsToDIP(ScaleFactorForDisplay(window), hit_area));
+        WindowMus::Get(window)->server_id(), offset.x() * device_scale_factor,
+        offset.y() * device_scale_factor,

[sadrul, 2016/12/21 16:22:44]

Use gfx::ScaleVector2d(offset, device_scale_factor)

[riajiang, 2016/12/21 17:48:32]

Done.

+        gfx::ConvertInsetsToPixel(device_scale_factor, hit_area));
   }
 }
 
 void WindowTreeClient::RequestClose(Window* window) {
   DCHECK(window);
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmRequestClose(
         WindowMus::Get(window)->server_id());
 }
 
@@ skipping 144 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