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

ui/views/mus/native_widget_mus.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.
 
 // This has to be before any other includes, else default is picked up.
 // See base/logging for details on this.
 #define NOTIMPLEMENTED_POLICY 5
 
 #include "ui/views/mus/native_widget_mus.h"
 
@@ skipping 20 matching lines @@
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/path.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/views/corewm/tooltip.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/corewm/tooltip_controller.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/mus/drag_drop_client_mus.h"
 #include "ui/views/mus/drop_target_mus.h"
 #include "ui/views/mus/input_method_mus.h"
@@ skipping 336 matching lines @@
                      const char* const property,
                      const gfx::ImageSkia& icon) {
   // TODO(crbug.com/667566): Support additional scales or gfx::Image[Skia].
   SkBitmap bitmap = icon.GetRepresentation(1.f).sk_bitmap();
   if (!bitmap.isNull())
     window->SetSharedProperty<SkBitmap>(property, bitmap);
   else if (window->HasSharedProperty(property))
     window->ClearSharedProperty(property);
 }
 
+// Helper function to get the device_scale_factor() of the display::Display
+// nearest to |window|.
+float ScaleFactorForDisplay(aura::Window* window) {
+  return display::Screen::GetScreen()
+      ->GetDisplayNearestWindow(window)
+      .device_scale_factor();
+}
+
 }  // namespace
 
 class NativeWidgetMus::MusWindowObserver : public ui::WindowObserver {
  public:
   explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
       : native_widget_mus_(native_widget_mus),
         show_state_(ui::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
@@ skipping 46 matching lines @@
     platform_window_delegate()->OnWindowStateChanged(state);
   }
   void OnWindowDestroyed(ui::Window* window) override {
     DCHECK_EQ(mus_window(), window);
     platform_window_delegate()->OnClosed();
   }
   void OnWindowBoundsChanging(ui::Window* window,
                               const gfx::Rect& old_bounds,
                               const gfx::Rect& new_bounds) override {
     DCHECK_EQ(window, mus_window());
-    window_tree_host()->SetBoundsInPixels(new_bounds);
+    window_tree_host()->SetBoundsInPixels(gfx::ConvertRectToPixel(
+        ScaleFactorForDisplay(aura_window()), new_bounds));
   }
   void OnWindowFocusChanged(ui::Window* gained_focus,
                             ui::Window* lost_focus) override {
     if (gained_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(true);
     else if (lost_focus == mus_window())
       platform_window_delegate()->OnActivationChanged(false);
   }
   void OnRequestClose(ui::Window* window) override {
     platform_window_delegate()->OnCloseRequest();
   }
 
  private:
   ui::Window* mus_window() { return native_widget_mus_->window(); }
+  aura::Window* aura_window() { return native_widget_mus_->aura_window(); }
   WindowTreeHostMus* window_tree_host() {
     return native_widget_mus_->window_tree_host();
   }
   ui::PlatformWindowDelegate* platform_window_delegate() {
     return native_widget_mus_->window_tree_host();
   }
 
   NativeWidgetMus* native_widget_mus_;
   ui::mojom::ShowState show_state_;
 
@@ skipping 523 matching lines @@
   origin.Offset(-display_origin.x(), -display_origin.y());
 
   gfx::Size size(bounds_in_screen.size());
   const gfx::Size min_size = GetMinimumSize();
   const gfx::Size max_size = GetMaximumSize();
   if (!max_size.IsEmpty())
     size.SetToMin(max_size);
   size.SetToMax(min_size);
   window_->SetBounds(gfx::Rect(origin, size));
   // Observer on |window_tree_host_| expected to synchronously update bounds.
-  DCHECK(window_->bounds() == window_tree_host_->GetBoundsInPixels());
+  DCHECK_EQ(gfx::ConvertRectToPixel(ScaleFactorForDisplay(content_),
+                                    window_->bounds())
+                .ToString(),
+            window_tree_host_->GetBoundsInPixels().ToString());
 }
 
 void NativeWidgetMus::SetSize(const gfx::Size& size) {
   if (!window_tree_host_)
     return;
 
   gfx::Rect bounds = window_tree_host_->GetBoundsInPixels();
   SetBounds(gfx::Rect(bounds.origin(), size));
 }
 
@@ skipping 533 matching lines @@
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views