Rename WindowTreeHost functions to indicate pixels/dips.

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 582 matching lines @@
 }
 
 void DesktopWindowTreeHostX11::SetSize(const gfx::Size& requested_size) {
   gfx::Size size_in_pixels = ToPixelRect(gfx::Rect(requested_size)).size();
   size_in_pixels = AdjustSize(size_in_pixels);
   bool size_changed = bounds_in_pixels_.size() != size_in_pixels;
   XResizeWindow(xdisplay_, xwindow_, size_in_pixels.width(),
                 size_in_pixels.height());
   bounds_in_pixels_.set_size(size_in_pixels);
   if (size_changed) {
-    OnHostResized(size_in_pixels);
+    OnHostResizedInPixel(size_in_pixels);
     ResetWindowRegion();
   }
 }
 
 void DesktopWindowTreeHostX11::StackAbove(aura::Window* window) {
   if (window && window->GetRootWindow()) {
     ::Window window_below = window->GetHost()->GetAcceleratedWidget();
     // Find all parent windows up to the root.
     std::vector<::Window> window_below_parents =
         GetParentsList(xdisplay_, window_below);
@@ skipping 447 matching lines @@
   //   synchronously.
   // See https://crbug.com/361408
   if (fullscreen) {
     restored_bounds_in_pixels_ = bounds_in_pixels_;
     const display::Display display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(window());
     bounds_in_pixels_ = ToPixelRect(display.bounds());
   } else {
     bounds_in_pixels_ = restored_bounds_in_pixels_;
   }
-  OnHostMoved(bounds_in_pixels_.origin());
-  OnHostResized(bounds_in_pixels_.size());
+  OnHostMovedInPixel(bounds_in_pixels_.origin());
+  OnHostResizedInPixel(bounds_in_pixels_.size());
 
   if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN") == fullscreen) {
     Relayout();
     ResetWindowRegion();
   }
   // Else: the widget will be relaid out either when the window bounds change or
   // when |xwindow_|'s fullscreen state changes.
 }
 
 bool DesktopWindowTreeHostX11::IsFullscreen() const {
@@ skipping 168 matching lines @@
   // Assume that the resize will go through as requested, which should be the
   // case if we're running without a window manager.  If there's a window
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
   // |bounds_in_pixels_| later.
   bounds_in_pixels_ = bounds_in_pixels;
 
   if (origin_changed)
     native_widget_delegate_->AsWidget()->OnNativeWidgetMove();
   if (size_changed) {
-    OnHostResized(bounds_in_pixels.size());
+    OnHostResizedInPixel(bounds_in_pixels.size());
     ResetWindowRegion();
   }
 }
 
-gfx::Point DesktopWindowTreeHostX11::GetLocationOnNativeScreen() const {
+gfx::Point DesktopWindowTreeHostX11::GetLocationOnNativeScreenInPixel() const {
   return bounds_in_pixels_.origin();
 }
 
 void DesktopWindowTreeHostX11::SetCapture() {
   if (HasCapture())
     return;
 
   // Grabbing the mouse is asynchronous. However, we synchronously start
   // forwarding all mouse events received by Chrome to the
   // aura::WindowEventDispatcher which has capture. This makes capture
@@ skipping 24 matching lines @@
     has_pointer_grab_ = false;
 
     OnHostLostWindowCapture();
   }
 }
 
 void DesktopWindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
-void DesktopWindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
+void DesktopWindowTreeHostX11::MoveCursorToNativeInPixel(
+    const gfx::Point& location_in_pixel) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
-               bounds_in_pixels_.x() + location.x(),
-               bounds_in_pixels_.y() + location.y());
+               bounds_in_pixels_.x() + location_in_pixel.x(),
+               bounds_in_pixels_.y() + location_in_pixel.y());
 }
 
 void DesktopWindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   // TODO(erg): Conditional on us enabling touch on desktop linux builds, do
   // the same tap-to-click disabling here that chromeos does.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, private:
 
@@ skipping 244 matching lines @@
   bool was_minimized = IsMinimized();
 
   window_properties_.clear();
   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,
+  // calling OnHostResizedInPixel() 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.
   // 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) {
@@ skipping 198 matching lines @@
 void DesktopWindowTreeHostX11::ConvertEventToDifferentHost(
     ui::LocatedEvent* located_event,
     DesktopWindowTreeHostX11* host) {
   DCHECK_NE(this, host);
   const display::Display display_src =
       display::Screen::GetScreen()->GetDisplayNearestWindow(window());
   const display::Display display_dest =
       display::Screen::GetScreen()->GetDisplayNearestWindow(host->window());
   DCHECK_EQ(display_src.device_scale_factor(),
             display_dest.device_scale_factor());
-  gfx::Vector2d offset = GetLocationOnNativeScreen() -
-                         host->GetLocationOnNativeScreen();
+  gfx::Vector2d offset = GetLocationOnNativeScreenInPixel() -
+                         host->GetLocationOnNativeScreenInPixel();
   gfx::PointF location_in_pixel_in_host =
       located_event->location_f() + gfx::Vector2dF(offset);
   located_event->set_location_f(location_in_pixel_in_host);
   located_event->set_root_location_f(location_in_pixel_in_host);
 }
 
 void DesktopWindowTreeHostX11::ResetWindowRegion() {
   // If a custom window shape was supplied then apply it.
   if (custom_window_shape_) {
     XShapeCombineRegion(xdisplay_, xwindow_, ShapeBounding, 0, 0,
@@ skipping 233 matching lines @@
       }
       gfx::Rect bounds_in_pixels(translated_x_in_pixels, translated_y_in_pixels,
                                  xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_in_pixels_.size() != bounds_in_pixels.size();
       bool origin_changed =
           bounds_in_pixels_.origin() != bounds_in_pixels.origin();
       previous_bounds_in_pixels_ = bounds_in_pixels_;
       bounds_in_pixels_ = bounds_in_pixels;
 
       if (origin_changed)
-        OnHostMoved(bounds_in_pixels_.origin());
+        OnHostMovedInPixel(bounds_in_pixels_.origin());
 
       if (size_changed) {
         delayed_resize_task_.Reset(base::Bind(
             &DesktopWindowTreeHostX11::DelayedResize,
             close_widget_factory_.GetWeakPtr(), bounds_in_pixels.size()));
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, delayed_resize_task_.callback());
       }
       break;
     }
@@ skipping 192 matching lines @@
     }
     case SelectionNotify: {
       drag_drop_client_->OnSelectionNotify(xev->xselection);
       break;
     }
   }
   return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
 void DesktopWindowTreeHostX11::DelayedResize(const gfx::Size& size_in_pixels) {
-  OnHostResized(size_in_pixels);
+  OnHostResizedInPixel(size_in_pixels);
   ResetWindowRegion();
   delayed_resize_task_.Cancel();
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetWorkAreaBoundsInPixels() const {
   std::vector<int> value;
   if (ui::GetIntArrayProperty(x_root_window_, "_NET_WORKAREA", &value) &&
       value.size() >= 4) {
     return gfx::Rect(value[0], value[1], value[2], value[3]);
   }
@@ skipping 68 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