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

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 "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/surface_id_handler.h"
@@ skipping 129 matching lines @@
       case ServerChangeType::ADD:
       case ServerChangeType::ADD_TRANSIENT:
       case ServerChangeType::REMOVE:
       case ServerChangeType::REMOVE_TRANSIENT:
       case ServerChangeType::REORDER:
       case ServerChangeType::TRANSIENT_REORDER:
         if (iter->data.child_id == data.child_id)
           return iter;
         break;
       case ServerChangeType::BOUNDS:
-        if (iter->data.bounds == data.bounds)
+        if (iter->data.bounds_in_dip == data.bounds_in_dip)
           return iter;
         break;
       case ServerChangeType::DESTROY:
         // No extra data for delete.
         return iter;
       case ServerChangeType::PROPERTY:
         if (iter->data.property_name == data.property_name)
           return iter;
         break;
       case ServerChangeType::VISIBLE:
@@ skipping 38 matching lines @@
   data.child_id = child->server_id();
   ScopedServerChange change(this, ServerChangeType::REORDER, data);
   if (direction == ui::mojom::OrderDirection::BELOW)
     window_->StackChildBelow(child->GetWindow(), relative->GetWindow());
   else
     window_->StackChildAbove(child->GetWindow(), relative->GetWindow());
 }
 
 void WindowPortMus::SetBoundsFromServer(const gfx::Rect& bounds) {
   ServerChangeData data;
-  data.bounds = bounds;
+  data.bounds_in_dip = bounds;
   ScopedServerChange change(this, ServerChangeType::BOUNDS, data);
   window_->SetBounds(bounds);
 }
 
 void WindowPortMus::SetVisibleFromServer(bool visible) {
   ServerChangeData data;
   data.visible = visible;
   ScopedServerChange change(this, ServerChangeType::VISIBLE, data);
   if (visible)
     window_->Show();
@@ skipping 95 matching lines @@
                                    change_data)
              ? ChangeSource::SERVER
              : ChangeSource::LOCAL;
 }
 
 std::unique_ptr<WindowMusChangeData>
 WindowPortMus::PrepareForServerBoundsChange(const gfx::Rect& bounds) {
   std::unique_ptr<WindowMusChangeDataImpl> data(
       base::MakeUnique<WindowMusChangeDataImpl>());
   ServerChangeData change_data;
-  change_data.bounds = bounds;
+  change_data.bounds_in_dip = bounds;
   data->change = base::MakeUnique<ScopedServerChange>(
       this, ServerChangeType::BOUNDS, change_data);
   return std::move(data);
 }
 
 std::unique_ptr<WindowMusChangeData>
 WindowPortMus::PrepareForServerVisibilityChange(bool value) {
   std::unique_ptr<WindowMusChangeDataImpl> data(
       base::MakeUnique<WindowMusChangeDataImpl>());
   ServerChangeData change_data;
@@ skipping 65 matching lines @@
 void WindowPortMus::OnVisibilityChanged(bool visible) {
   ServerChangeData change_data;
   change_data.visible = visible;
   if (!RemoveChangeByTypeAndData(ServerChangeType::VISIBLE, change_data))
     window_tree_client_->OnWindowMusSetVisible(this, visible);
 }
 
 void WindowPortMus::OnDidChangeBounds(const gfx::Rect& old_bounds,
                                       const gfx::Rect& new_bounds) {
   ServerChangeData change_data;
-  change_data.bounds = new_bounds;
+  change_data.bounds_in_dip = new_bounds;
   if (!RemoveChangeByTypeAndData(ServerChangeType::BOUNDS, change_data))
     window_tree_client_->OnWindowMusBoundsChanged(this, old_bounds, new_bounds);
 }
 
 std::unique_ptr<WindowPortPropertyData> WindowPortMus::OnWillChangeProperty(
     const void* key) {
   return window_tree_client_->OnWindowMusWillChangeProperty(this, key);
 }
 
 void WindowPortMus::OnPropertyChanged(
     const void* key,
     std::unique_ptr<WindowPortPropertyData> data) {
   ServerChangeData change_data;
   change_data.property_name =
       GetPropertyConverter()->GetTransportNameForPropertyKey(key);
   // TODO(sky): investigate to see if we need to compare data. In particular do
   // we ever have a case where changing a property cascades into changing the
   // same property?
   if (!RemoveChangeByTypeAndData(ServerChangeType::PROPERTY, change_data))
     window_tree_client_->OnWindowMusPropertyChanged(this, key, std::move(data));
 }
 
 }  // namespace aura