Rename WindowTreeHost G|SetBounds to indicate they are in pixels.

ui/aura/window_tree_host.cc

 // Copyright (c) 2013 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/window_tree_host.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 43 matching lines @@
 
 // static
 WindowTreeHost* WindowTreeHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget widget) {
   return reinterpret_cast<WindowTreeHost*>(
       ui::ViewProp::GetValue(widget, kWindowTreeHostForAcceleratedWidget));
 }
 
 void WindowTreeHost::InitHost() {
   InitCompositor();
-  UpdateRootWindowSize(GetBounds().size());
+  UpdateRootWindowSize(GetBoundsInPixel().size());
   Env::GetInstance()->NotifyHostInitialized(this);
   window()->Show();
 }
 
 void WindowTreeHost::InitCompositor() {
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
-                               GetBounds().size());
+                               GetBoundsInPixel().size());
   compositor_->SetRootLayer(window()->layer());
   compositor_->SetDisplayColorSpace(
       GetICCProfileForCurrentDisplay().GetColorSpace());
 }
 
 void WindowTreeHost::AddObserver(WindowTreeHostObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeHost::RemoveObserver(WindowTreeHostObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ui::EventProcessor* WindowTreeHost::event_processor() {
   return dispatcher();
 }
 
 gfx::Transform WindowTreeHost::GetRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(window()->layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= window()->layer()->transform();
   return transform;
 }
 
 void WindowTreeHost::SetRootTransform(const gfx::Transform& transform) {
   window()->SetTransform(transform);
-  UpdateRootWindowSize(GetBounds().size());
+  UpdateRootWindowSize(GetBoundsInPixel().size());
 }
 
 gfx::Transform WindowTreeHost::GetInverseRootTransform() const {
   gfx::Transform invert;
   gfx::Transform transform = GetRootTransform();
   if (!transform.GetInverse(&invert))
     return transform;
   return invert;
 }
 
 void WindowTreeHost::SetOutputSurfacePadding(const gfx::Insets& padding) {
   if (output_surface_padding_ == padding)
     return;
 
   output_surface_padding_ = padding;
-  OnHostResized(GetBounds().size());
+  OnHostResized(GetBoundsInPixel().size());
 }
 
 void WindowTreeHost::UpdateRootWindowSize(const gfx::Size& host_size) {
   gfx::Rect bounds(output_surface_padding_.left(),
                    output_surface_padding_.top(), host_size.width(),
                    host_size.height());
   float scale_factor = ui::GetDeviceScaleFactor(window()->layer());
   gfx::RectF new_bounds =
       gfx::ScaleRect(gfx::RectF(bounds), 1.0f / scale_factor);
   window()->layer()->transform().TransformRect(&new_bounds);
@@ skipping 152 matching lines @@
 
 void WindowTreeHost::OnHostResized(const gfx::Size& new_size) {
   gfx::Size adjusted_size(new_size);
   adjusted_size.Enlarge(output_surface_padding_.width(),
                         output_surface_padding_.height());
   // The compositor should have the same size as the native root window host.
   // Get the latest scale from display because it might have been changed.
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(window()),
                                adjusted_size);
 
-  gfx::Size layer_size = GetBounds().size();
+  gfx::Size layer_size = GetBoundsInPixel().size();
   // The layer, and the observers should be notified of the
   // transformed size of the root window.
   UpdateRootWindowSize(layer_size);
   for (WindowTreeHostObserver& observer : observers_)
     observer.OnHostResized(this);
 }
 
 void WindowTreeHost::OnHostWorkspaceChanged() {
   for (WindowTreeHostObserver& observer : observers_)
     observer.OnHostWorkspaceChanged(this);
@@ skipping 34 matching lines @@
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   if (cursor_client) {
     const display::Display& display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(window());
     cursor_client->SetDisplay(display);
   }
   dispatcher()->OnCursorMovedToRootLocation(root_location);
 }
 
 }  // namespace aura