Rename gfx::Display/Screen to display::Display/Screen in chrome

chrome/browser/ui/window_sizer/window_sizer.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 CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_
 #define CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/geometry/rect.h"
 
 class Browser;
 
 namespace gfx {
 class Display;
 class Screen;
 }
 
+namespace display {
+using Display = gfx::Display;
+using Screen = gfx::Screen;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer
 //
 //  A class that determines the best new size and position for a window to be
 //  shown at based several factors, including the position and size of the last
 //  window of the same type, the last saved bounds of the window from the
 //  previous session, and default system metrics if neither of the above two
 //  conditions exist. The system has built-in providers for monitor metrics
 //  and persistent storage (using preferences) but can be overrided with mocks
 //  for testing.
 //
 class WindowSizer {
  public:
   class StateProvider;
   class TargetDisplayProvider;
 
   // WindowSizer owns |state_provider| and |target_display_provider|,
-  // and will use the platforms's gfx::Screen.
+  // and will use the platforms's display::Screen.
   WindowSizer(std::unique_ptr<StateProvider> state_provider,
               std::unique_ptr<TargetDisplayProvider> target_display_provider,
               const Browser* browser);
 
   // WindowSizer owns |state_provider| and |target_display_provider|,
   // and will use the supplied |screen|. Used only for testing.
   WindowSizer(std::unique_ptr<StateProvider> state_provider,
               std::unique_ptr<TargetDisplayProvider> target_display_provider,
-              gfx::Screen* screen,
+              display::Screen* screen,
               const Browser* browser);
 
   virtual ~WindowSizer();
 
   // An interface implemented by an object that can retrieve state from either a
   // persistent store or an existing window.
   class StateProvider {
    public:
     virtual ~StateProvider() {}
 
@@ skipping 13 matching lines @@
     virtual bool GetLastActiveWindowState(
         gfx::Rect* bounds,
         ui::WindowShowState* show_state) const = 0;
   };
 
   // An interface implemented by an object to identify on which
   // display a new window should be located.
   class TargetDisplayProvider {
     public:
       virtual ~TargetDisplayProvider() {}
-      virtual gfx::Display GetTargetDisplay(const gfx::Screen* screen,
-                                            const gfx::Rect& bounds) const = 0;
+      virtual display::Display GetTargetDisplay(
+          const display::Screen* screen,
+          const gfx::Rect& bounds) const = 0;
   };
 
   // Determines the position and size for a window as it is created as well
   // as the initial state. This function uses several strategies to figure out
   // optimal size and placement, first looking for an existing active window,
   // then falling back to persisted data from a previous session, finally
   // utilizing a default algorithm. If |specified_bounds| are non-empty, this
   // value is returned instead. For use only in testing.
   // |show_state| will be overwritten and return the initial visual state of
   // the window to use.
@@ skipping 37 matching lines @@
   // this information, false if this information does not exist and a default
   // size should be used.
   // |show_state| will only be changed if it was set to SHOW_STATE_DEFAULT.
   bool GetSavedWindowBounds(gfx::Rect* bounds,
                             ui::WindowShowState* show_state) const;
 
   // Gets the default window position and size to be shown on
   // |display| if there is no last window and no saved window
   // placement in prefs. This function determines the default size
   // based on monitor size, etc.
-  void GetDefaultWindowBounds(const gfx::Display& display,
+  void GetDefaultWindowBounds(const display::Display& display,
                               gfx::Rect* default_bounds) const;
 
   // Adjusts |bounds| to be visible on-screen, biased toward the work area of
   // the |display|.  Despite the name, this doesn't
   // guarantee the bounds are fully contained within this display's work rect;
   // it just tried to ensure the edges are visible on _some_ work rect.
   // If |saved_work_area| is non-empty, it is used to determine whether the
   // monitor configuration has changed. If it has, bounds are repositioned and
   // resized if necessary to make them completely contained in the current work
   // area.
-  void AdjustBoundsToBeVisibleOnDisplay(
-      const gfx::Display& display,
-      const gfx::Rect& saved_work_area,
-      gfx::Rect* bounds) const;
+  void AdjustBoundsToBeVisibleOnDisplay(const display::Display& display,
+                                        const gfx::Rect& saved_work_area,
+                                        gfx::Rect* bounds) const;
 
   // Determine the target display for a new window based on
   // |bounds|. On ash environment, this returns the display containing
   // ash's the target root window.
-  gfx::Display GetTargetDisplay(const gfx::Rect& bounds) const;
+  display::Display GetTargetDisplay(const gfx::Rect& bounds) const;
 
 #if defined(USE_ASH)
   // Ash specific logic for window placement. Returns true if |bounds| and
   // |show_state| have been fully determined, otherwise returns false (but
   // may still affect |show_state|).
   // If the window is too big to fit in the display work area then the |bounds|
   // are adjusted to default bounds and the |show_state| is adjusted to
   // SHOW_STATE_MAXIMIZED.
   bool GetBrowserBoundsAsh(gfx::Rect* bounds,
                            ui::WindowShowState* show_state) const;
 
   // Determines the position and size for a tabbed browser window in
   // ash as it gets created. This will be called before other standard
   // placement logic. |show_state| will only be changed
   // if it was set to SHOW_STATE_DEFAULT.
   void GetTabbedBrowserBoundsAsh(gfx::Rect* bounds,
                                  ui::WindowShowState* show_state) const;
 #endif
 
   // Determine the default show state for the window - not looking at other
   // windows or at persistent information.
   ui::WindowShowState GetWindowDefaultShowState() const;
 
   // Providers for persistent storage and monitor metrics.
   std::unique_ptr<StateProvider> state_provider_;
   std::unique_ptr<TargetDisplayProvider> target_display_provider_;
-  gfx::Screen* screen_;  // not owned.
+  display::Screen* screen_;  // not owned.
 
   // Note that this browser handle might be NULL.
   const Browser* browser_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSizer);
 };
 
 #endif  // CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_