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

ui/aura/window_tree_host.h

 // 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.
 
 #ifndef UI_AURA_WINDOW_TREE_HOST_H_
 #define UI_AURA_WINDOW_TREE_HOST_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 34 matching lines @@
 
 // WindowTreeHost bridges between a native window and the embedded RootWindow.
 // It provides the accelerated widget and maps events from the native os to
 // aura.
 class AURA_EXPORT WindowTreeHost : public ui::internal::InputMethodDelegate,
                                    public ui::EventSource {
  public:
   ~WindowTreeHost() override;
 
   // Creates a new WindowTreeHost. The caller owns the returned value.
   static WindowTreeHost* Create(const gfx::Rect& bounds);

[sky, 2016/11/22 21:38:15]

rename this to bounds_in_pixels too.

 
   // Returns the WindowTreeHost for the specified accelerated widget, or NULL
   // if there is none associated.
   static WindowTreeHost* GetForAcceleratedWidget(gfx::AcceleratedWidget widget);
 
   void InitHost();
 
   void InitCompositor();
 
   void AddObserver(WindowTreeHostObserver* observer);
@@ skipping 23 matching lines @@
   // padding.top().
   // This does not impact the bounds as returned from GetBounds(), only the
   // output surface size and location of window(). Additionally window() is
   // sized to the size set by bounds (more specifically the size passed to
   // OnHostResized()), but the location of window() is set to that of
   // |padding|.
   void SetOutputSurfacePadding(const gfx::Insets& padding);
 
   // Updates the root window's size using |host_size|, current
   // transform and outsets.
   virtual void UpdateRootWindowSize(const gfx::Size& host_size);

[sadrul, 2016/11/23 03:08:20]

Update this too in a follow up CL.

 
   // Converts |point| from the root window's coordinate system to native
   // screen's.
   void ConvertPointToNativeScreen(gfx::Point* point) const;

[sky, 2016/11/22 21:38:15]

All of these should be InPixels too.

 
   // Converts |point| from native screen coordinate system to the root window's.
   void ConvertPointFromNativeScreen(gfx::Point* point) const;
 
   // Converts |point| from the root window's coordinate system to the
   // host window's.
   void ConvertPointToHost(gfx::Point* point) const;
 
   // Converts |point| from the host window's coordinate system to the
   // root window's.
   void ConvertPointFromHost(gfx::Point* point) const;
 
   // Cursor.
   // Sets the currently-displayed cursor. If the cursor was previously hidden
   // via ShowCursor(false), it will remain hidden until ShowCursor(true) is
   // called, at which point the cursor that was last set via SetCursor() will be
   // used.
   void SetCursor(gfx::NativeCursor cursor);
 
   // Invoked when the cursor's visibility has changed.
   void OnCursorVisibilityChanged(bool visible);
 
   // Moves the cursor to the specified location relative to the root window.
   void MoveCursorTo(const gfx::Point& location);

[sky, 2016/11/22 21:38:15]

LocationInPixels

 
   // Moves the cursor to the |host_location| given in host coordinates.
   void MoveCursorToHostLocation(const gfx::Point& host_location);

[sky, 2016/11/22 21:38:15]

InPixels

 
   gfx::NativeCursor last_cursor() const { return last_cursor_; }
 
   // Gets the InputMethod instance, if NULL, creates & owns it.
   ui::InputMethod* GetInputMethod();
 
   // Sets a shared unowned InputMethod. This is used when there is a singleton
   // InputMethod shared between multiple WindowTreeHost instances.
   //
   // This is used for Ash only. There are 2 reasons:
@@ skipping 25 matching lines @@
   // Returns the accelerated widget.
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() = 0;
 
   // Shows the WindowTreeHost.
   void Show();
 
   // Hides the WindowTreeHost.
   void Hide();
 
   // Gets/Sets the size of the WindowTreeHost (in pixels).
-  virtual gfx::Rect GetBounds() const = 0;
-  virtual void SetBounds(const gfx::Rect& bounds_in_pixels) = 0;
+  virtual gfx::Rect GetBoundsInPixel() const = 0;
+  virtual void SetBoundsInPixel(const gfx::Rect& bounds_in_pixels) = 0;
 
   // Sets the OS capture to the root window.
   virtual void SetCapture() = 0;
 
   // Releases OS capture of the root window.
   virtual void ReleaseCapture() = 0;
 
  protected:
   friend class TestScreen;  // TODO(beng): see if we can remove/consolidate.
 
   WindowTreeHost();
   explicit WindowTreeHost(std::unique_ptr<WindowPort> window_port);
 
   void DestroyCompositor();
   void DestroyDispatcher();
 
   void CreateCompositor();
   void OnAcceleratedWidgetAvailable();
 
   // Returns the location of the RootWindow on native screen.
   virtual gfx::Point GetLocationOnNativeScreen() const = 0;

[sky, 2016/11/22 21:38:15]

GetLocationOnNativeScreenInPixels.

 
   void OnHostMoved(const gfx::Point& new_location);

[sky, 2016/11/22 21:38:15]

OnHostMovedInPixels

   void OnHostResized(const gfx::Size& new_size);

[sky, 2016/11/22 21:38:16]

OnHostResizedInPixels

   void OnHostWorkspaceChanged();
   void OnHostCloseRequested();
   void OnHostActivated();
   void OnHostLostWindowCapture();
 
   // Sets the currently displayed cursor.
   virtual void SetCursorNative(gfx::NativeCursor cursor) = 0;
 
   // Moves the cursor to the specified location relative to the root window.
   virtual void MoveCursorToNative(const gfx::Point& location) = 0;

[sky, 2016/11/22 21:38:15]

MoveCursorToNativeLocationInPixels.

 
   // kCalled when the cursor visibility has changed.
   virtual void OnCursorVisibilityChangedNative(bool show) = 0;
 
   // Shows the WindowTreeHost.
   virtual void ShowImpl() = 0;
 
   // Hides the WindowTreeHost.
   virtual void HideImpl() = 0;
 
@@ skipping 37 matching lines @@
   bool owned_input_method_;
 
   gfx::Insets output_surface_padding_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTreeHost);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_TREE_HOST_H_