Aura-Mus: Fix high-DPI gutter

ui/aura/mus/window_port_mus.cc

 // Copyright 2016 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_port_mus.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/client_surface_embedder.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/gfx/geometry/dip_util.h"
 
 namespace aura {
 
 namespace {
 // 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();
@@ skipping 211 matching lines @@
   else
     window_->StackChildAbove(child->GetWindow(), relative->GetWindow());
 }
 
 void WindowPortMus::SetBoundsFromServer(
     const gfx::Rect& bounds,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   ServerChangeData data;
   data.bounds_in_dip = bounds;
   ScopedServerChange change(this, ServerChangeType::BOUNDS, data);
-  last_surface_size_ = bounds.size();
+  float device_scale_factor = ScaleFactorForDisplay(window_);
+  last_surface_size_in_pixels_ =
+      gfx::ConvertSizeToPixel(device_scale_factor, bounds.size());
   if (local_surface_id)
     local_surface_id_ = *local_surface_id;
   else
     local_surface_id_ = cc::LocalSurfaceId();
   window_->SetBounds(bounds);
 }
 
 void WindowPortMus::SetVisibleFromServer(bool visible) {
   ServerChangeData data;
   data.visible = visible;
@@ skipping 32 matching lines @@
     // CompositorFrameSinks.
     DCHECK_NE(WindowMusType::TOP_LEVEL_IN_WM, window_mus_type());
     DCHECK_NE(WindowMusType::EMBED_IN_OWNER, window_mus_type());
     base::ResetAndReturn(&pending_compositor_frame_sink_request_).Run();
     return;
   }
   UpdatePrimarySurfaceInfo();
 }
 
 const cc::LocalSurfaceId& WindowPortMus::GetOrAllocateLocalSurfaceId(
-    const gfx::Size& surface_size) {
-  if (last_surface_size_ == surface_size && local_surface_id_.is_valid())
+    const gfx::Size& surface_size_in_pixels) {
+  if (last_surface_size_in_pixels_ == surface_size_in_pixels &&
+      local_surface_id_.is_valid()) {
     return local_surface_id_;
+  }
 
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
-  last_surface_size_ = surface_size;
+  last_surface_size_in_pixels_ = surface_size_in_pixels;
 
   // If surface synchronization is enabled and the FrameSinkId is available,
   // then immediately embed the SurfaceId. The newly generated frame by the
   // embedder will block in the display compositor until the child submits a
   // corresponding CompositorFrame or a deadline hits.
   if (window_tree_client_->enable_surface_synchronization_ &&
       frame_sink_id_.is_valid()) {
     UpdatePrimarySurfaceInfo();
   }
 
@@ skipping 202 matching lines @@
 
 void WindowPortMus::UpdatePrimarySurfaceInfo() {
   bool embeds_surface = window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
                         window_mus_type() == WindowMusType::EMBED_IN_OWNER;
   if (!embeds_surface || !window_tree_client_->enable_surface_synchronization_)
     return;
 
   if (!frame_sink_id_.is_valid() || !local_surface_id_.is_valid())
     return;
 
-  SetPrimarySurfaceInfo(
-      cc::SurfaceInfo(cc::SurfaceId(frame_sink_id_, local_surface_id_),
-                      ScaleFactorForDisplay(window_), last_surface_size_));
+  SetPrimarySurfaceInfo(cc::SurfaceInfo(
+      cc::SurfaceId(frame_sink_id_, local_surface_id_),
+      ScaleFactorForDisplay(window_), last_surface_size_in_pixels_));
 }
 
 void WindowPortMus::UpdateClientSurfaceEmbedder() {
   bool embeds_surface = window_mus_type() == WindowMusType::TOP_LEVEL_IN_WM ||
                         window_mus_type() == WindowMusType::EMBED_IN_OWNER;
   if (!embeds_surface)
     return;
 
   if (!client_surface_embedder_) {
     client_surface_embedder_ = base::MakeUnique<ClientSurfaceEmbedder>(
         window_, window_tree_client_->normal_client_area_insets_);
   }
 
   client_surface_embedder_->SetPrimarySurfaceInfo(primary_surface_info_);
   client_surface_embedder_->SetFallbackSurfaceInfo(fallback_surface_info_);
 }
 
 }  // namespace aura