Rename WindowTreeHost functions to indicate pixels/dips.

ui/aura/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/aura/window_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 294 matching lines @@
       // It's possible that the X window may be resized by some other means
       // than from within aura (e.g. the X window manager can change the
       // size). Make sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
           xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bool origin_changed = bounds_.origin() != bounds.origin();
       bounds_ = bounds;
       OnConfigureNotify();
       if (size_changed)
-        OnHostResized(bounds.size());
+        OnHostResizedInPixels(bounds.size());
       if (origin_changed)
-        OnHostMoved(bounds_.origin());
+        OnHostMovedInPixels(bounds_.origin());
       break;
     }
     case GenericEvent:
       DispatchXI2Event(xev);
       break;
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
       if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
         // We have received a close message from the window manager.
         OnHostCloseRequested();
@@ skipping 98 matching lines @@
   if (value_mask)
     XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 
   // 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_| later.
   bounds_ = bounds;
   if (origin_changed)
-    OnHostMoved(bounds.origin());
+    OnHostMovedInPixels(bounds.origin());
   if (size_changed || current_scale != new_scale) {
-    OnHostResized(bounds.size());
+    OnHostResizedInPixels(bounds.size());
   } else {
     window()->SchedulePaintInRect(window()->bounds());
   }
 }
 
-gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const {
+gfx::Point WindowTreeHostX11::GetLocationOnNativeScreenInPixels() const {
   return bounds_.origin();
 }
 
 void WindowTreeHostX11::SetCapture() {
   // Do not grab X11 input. Grabbing X11 input is asynchronous and this method
   // is expected to be synchronous. Grabbing X11 input is unnecessary on
   // ChromeOS because ChromeOS manages all of the X windows. When running
   // ChromeOS on the desktop for the sake of debugging:
   // - Implicit pointer grab as a result of pressing a mouse button
   // - Releasing capture as a result of losing activation (FocusOut)
   // is sufficient.
 }
 
 void WindowTreeHostX11::ReleaseCapture() {
 }
 
 void WindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
   if (cursor == current_cursor_)
     return;
   current_cursor_ = cursor;
   SetCursorInternal(cursor);
 }
 
-void WindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
+void WindowTreeHostX11::MoveCursorToNativeInPixels(
+    const gfx::Point& location_in_pixels) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
-               bounds_.x() + location.x(),
-               bounds_.y() + location.y());
+               bounds_.x() + location_in_pixels.x(),
+               bounds_.y() + location_in_pixels.y());
 }
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
 }
 
 void WindowTreeHostX11::DisableInput() {
   xwindow_events_.reset(
       new ui::XScopedEventSelector(xwindow_, kEventMask & ~kInputEventMask));
   unsigned char mask[XIMaskLen(XI_LASTEVENT)] = {0};
   XIEventMask evmask;
@@ skipping 81 matching lines @@
 }
 
 void WindowTreeHostX11::OnConfigureNotify() {}
 
 void WindowTreeHostX11::TranslateAndDispatchLocatedEvent(
     ui::LocatedEvent* event) {
   SendEventToProcessor(event);
 }
 
 // static
-WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
-  return new WindowTreeHostX11(bounds);
+WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds_in_pixels) {
+  return new WindowTreeHostX11(bounds_in_pixels);
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura