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

chrome/browser/ui/window_sizer/window_sizer.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 "chrome/browser/ui/window_sizer/window_sizer.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/prefs/pref_service.h"
 #include "ui/base/ui_base_switches.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
 
 #if defined(USE_ASH)
 #include "ash/shell.h"
 #include "ash/wm/common/window_positioner.h"
 #include "chrome/browser/ui/ash/ash_util.h"
 #endif
 
 namespace {
 
 // Minimum height of the visible part of a window.
@@ skipping 111 matching lines @@
   // If set, is used as the reference browser for GetLastActiveWindowState.
   const Browser* browser_;
   DISALLOW_COPY_AND_ASSIGN(DefaultStateProvider);
 };
 
 class DefaultTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
  public:
   DefaultTargetDisplayProvider() {}
   ~DefaultTargetDisplayProvider() override {}
 
-  gfx::Display GetTargetDisplay(const gfx::Screen* screen,
-                                const gfx::Rect& bounds) const override {
+  display::Display GetTargetDisplay(const display::Screen* screen,
+                                    const gfx::Rect& bounds) const override {
 #if defined(USE_ASH)
     // Use the target display on ash.
     if (chrome::ShouldOpenAshOnStartup()) {
       aura::Window* target = ash::Shell::GetTargetRootWindow();
       return screen->GetDisplayNearestWindow(target);
     }
 #endif
     // Find the size of the work area of the monitor that intersects the bounds
     // of the anchor window.
     return screen->GetDisplayMatching(bounds);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultTargetDisplayProvider);
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, public:
 
 WindowSizer::WindowSizer(
     std::unique_ptr<StateProvider> state_provider,
     std::unique_ptr<TargetDisplayProvider> target_display_provider,
     const Browser* browser)
     : state_provider_(std::move(state_provider)),
       target_display_provider_(std::move(target_display_provider)),
-      screen_(gfx::Screen::GetScreen()),
+      screen_(display::Screen::GetScreen()),
       browser_(browser) {}
 
 WindowSizer::WindowSizer(
     std::unique_ptr<StateProvider> state_provider,
     std::unique_ptr<TargetDisplayProvider> target_display_provider,
-    gfx::Screen* screen,
+    display::Screen* screen,
     const Browser* browser)
     : state_provider_(std::move(state_provider)),
       target_display_provider_(std::move(target_display_provider)),
       screen_(screen),
       browser_(browser) {
   DCHECK(screen_);
 }
 
 WindowSizer::~WindowSizer() {
 }
@@ skipping 85 matching lines @@
       !state_provider_->GetPersistentState(bounds,
                                            &saved_work_area,
                                            show_state))
     return false;
   AdjustBoundsToBeVisibleOnDisplay(GetTargetDisplay(*bounds),
                                    saved_work_area,
                                    bounds);
   return true;
 }
 
-void WindowSizer::GetDefaultWindowBounds(const gfx::Display& display,
+void WindowSizer::GetDefaultWindowBounds(const display::Display& display,
                                          gfx::Rect* default_bounds) const {
   DCHECK(default_bounds);
 #if defined(USE_ASH)
   // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
   if (chrome::ShouldOpenAshOnStartup()) {
     *default_bounds = ash::WindowPositioner::GetDefaultWindowBounds(display);
     return;
   }
 #endif
   gfx::Rect work_area = display.work_area();
@@ skipping 20 matching lines @@
     // kWindowTilePixels between screen edge and each other.
     default_width = static_cast<int>(work_area.width() / 2. -
         1.5 * kWindowTilePixels);
   }
   default_bounds->SetRect(kWindowTilePixels + work_area.x(),
                           kWindowTilePixels + work_area.y(),
                           default_width, default_height);
 }
 
 void WindowSizer::AdjustBoundsToBeVisibleOnDisplay(
-    const gfx::Display& display,
+    const display::Display& display,
     const gfx::Rect& saved_work_area,
     gfx::Rect* bounds) const {
   DCHECK(bounds);
 
   // If |bounds| is empty, reset to the default size.
   if (bounds->IsEmpty()) {
     gfx::Rect default_bounds;
     GetDefaultWindowBounds(display, &default_bounds);
     if (bounds->height() <= 0)
       bounds->set_height(default_bounds.height());
@@ skipping 49 matching lines @@
   // ensure that at least kMinVisibleWidth * kMinVisibleHeight is visible.
   const int min_y = work_area.y() + kMinVisibleHeight - bounds->height();
   const int min_x = work_area.x() + kMinVisibleWidth - bounds->width();
   const int max_y = work_area.bottom() - kMinVisibleHeight;
   const int max_x = work_area.right() - kMinVisibleWidth;
   bounds->set_y(std::max(min_y, std::min(max_y, bounds->y())));
   bounds->set_x(std::max(min_x, std::min(max_x, bounds->x())));
 #endif  // defined(OS_MACOSX)
 }
 
-gfx::Display WindowSizer::GetTargetDisplay(const gfx::Rect& bounds) const {
+display::Display WindowSizer::GetTargetDisplay(const gfx::Rect& bounds) const {
   return target_display_provider_->GetTargetDisplay(screen_, bounds);
 }
 
 ui::WindowShowState WindowSizer::GetWindowDefaultShowState() const {
   if (!browser_)
     return ui::SHOW_STATE_DEFAULT;
 
   // Only tabbed browsers use the command line or preference state, with the
   // exception of devtools.
   bool show_state = !browser_->is_type_tabbed() && !browser_->is_devtools();
 
 #if defined(USE_AURA)
   // We use the apps save state on aura.
   show_state &= !browser_->is_app();
 #endif
 
   if (show_state)
     return browser_->initial_show_state();
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kStartMaximized))
     return ui::SHOW_STATE_MAXIMIZED;
 
   if (browser_->initial_show_state() != ui::SHOW_STATE_DEFAULT)
     return browser_->initial_show_state();
 
   // Otherwise we use the default which can be overridden later on.
   return ui::SHOW_STATE_DEFAULT;
 }