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

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.cc

 // Copyright (c) 2012 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/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 647 matching lines @@
   gfx::Rect window_bounds_in_pixels(
       parent_bounds_in_pixels.x() +
           (parent_bounds_in_pixels.width() - size_in_pixels.width()) / 2,
       parent_bounds_in_pixels.y() +
           (parent_bounds_in_pixels.height() - size_in_pixels.height()) / 2,
       size_in_pixels.width(), size_in_pixels.height());
   // Don't size the window bigger than the parent, otherwise the user may not be
   // able to close or move it.
   window_bounds_in_pixels.AdjustToFit(parent_bounds_in_pixels);
 
-  SetBounds(window_bounds_in_pixels);
+  SetBoundsInPixels(window_bounds_in_pixels);
 }
 
 void DesktopWindowTreeHostX11::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   *bounds = GetRestoredBounds();
 
   if (IsFullscreen()) {
     *show_state = ui::SHOW_STATE_FULLSCREEN;
   } else if (IsMinimized()) {
@@ skipping 164 matching lines @@
     SetWMSpecState(false,
                    atom_cache_.GetAtom("_NET_WM_STATE_FULLSCREEN"),
                    None);
 
     // Resize the window so that it does not have the same size as a monitor.
     // (Otherwise, some window managers immediately put the window back in
     // fullscreen mode).
     gfx::Rect adjusted_bounds_in_pixels(bounds_in_pixels_.origin(),
                                         AdjustSize(bounds_in_pixels_.size()));
     if (adjusted_bounds_in_pixels != bounds_in_pixels_)
-      SetBounds(adjusted_bounds_in_pixels);
+      SetBoundsInPixels(adjusted_bounds_in_pixels);
   }
 
   // Some WMs do not respect maximization hints on unmapped windows, so we
   // save this one for later too.
   should_maximize_after_map_ = !IsVisible();
 
   // When we are in the process of requesting to maximize a window, we can
   // accurately keep track of our restored bounds instead of relying on the
   // heuristics that are in the PropertyNotify and ConfigureNotify handlers.
   restored_bounds_in_pixels_ = bounds_in_pixels_;
@@ skipping 333 matching lines @@
 }
 
 void DesktopWindowTreeHostX11::HideImpl() {
   if (IsVisible()) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     wait_for_unmap_ = true;
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
-gfx::Rect DesktopWindowTreeHostX11::GetBounds() const {
+gfx::Rect DesktopWindowTreeHostX11::GetBoundsInPixels() const {
   return bounds_in_pixels_;
 }
 
-void DesktopWindowTreeHostX11::SetBounds(
+void DesktopWindowTreeHostX11::SetBoundsInPixels(
     const gfx::Rect& requested_bounds_in_pixel) {
   gfx::Rect bounds_in_pixels(requested_bounds_in_pixel.origin(),
                              AdjustSize(requested_bounds_in_pixel.size()));
   bool origin_changed = bounds_in_pixels_.origin() != bounds_in_pixels.origin();
   bool size_changed = bounds_in_pixels_.size() != bounds_in_pixels.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
 
   delayed_resize_task_.Cancel();
 
@@ skipping 350 matching lines @@
   std::copy(atom_list.begin(), atom_list.end(),
             inserter(window_properties_, window_properties_.begin()));
 
   // Propagate the window minimization information to the content window, so
   // the render side can update its visibility properly. OnWMStateUpdated() is
   // called by PropertyNofify event from DispatchEvent() when the browser is
   // minimized or shown from minimized state. On Windows, this is realized by
   // calling OnHostResized() with an empty size. In particular,
   // HWNDMessageHandler::GetClientAreaBounds() returns an empty size when the
   // window is minimized. On Linux, returning empty size in GetBounds() or
-  // SetBounds() does not work.
+  // SetBoundsInPixels() does not work.
   // We also propagate the minimization to the compositor, to makes sure that we
   // don't draw any 'blank' frames that could be noticed in applications such as
   // window manager previews, which show content even when a window is
   // minimized.
   bool is_minimized = IsMinimized();
   if (is_minimized != was_minimized) {
     if (is_minimized) {
       compositor()->SetVisible(false);
       content_window_->Hide();
     } else {
@@ skipping 752 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeThemeAura::instance();
 }
 
 }  // namespace views