Rename gfx::Screen::GetMonitorXXXX to gfx::Screen::GetDisplayXXX.

chrome/browser/ui/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.h"
 
 #include "base/compiler_specific.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.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/common/pref_names.h"
 #include "ui/gfx/screen.h"
 
 // Minimum height of the visible part of a window.
 const int kMinVisibleHeight = 30;
 // Minimum width of the visible part of a window.
 const int kMinVisibleWidth = 30;
 
 class DefaultMonitorInfoProvider : public MonitorInfoProvider {
  public:
   // Overridden from MonitorInfoProvider:
-  virtual gfx::Rect GetPrimaryMonitorWorkArea() const OVERRIDE {
-    return gfx::Screen::GetPrimaryMonitor().work_area();
+  virtual gfx::Rect GetPrimaryDisplayWorkArea() const OVERRIDE {
+    return gfx::Screen::GetPrimaryDisplay().work_area();
   }
-  virtual gfx::Rect GetPrimaryMonitorBounds() const OVERRIDE {
-    return gfx::Screen::GetPrimaryMonitor().bounds();
+  virtual gfx::Rect GetPrimaryDisplayBounds() const OVERRIDE {
+    return gfx::Screen::GetPrimaryDisplay().bounds();
   }
   virtual gfx::Rect GetMonitorWorkAreaMatching(
       const gfx::Rect& match_rect) const OVERRIDE {
-    return gfx::Screen::GetMonitorMatching(match_rect).work_area();
+    return gfx::Screen::GetDisplayMatching(match_rect).work_area();
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // An implementation of WindowSizer::StateProvider that gets the last active
 // and persistent state from the browser window and the user's profile.
 class DefaultStateProvider : public WindowSizer::StateProvider {
  public:
   DefaultStateProvider(const std::string& app_name, const Browser* browser)
       : app_name_(app_name), browser_(browser) {
@@ skipping 162 matching lines @@
     return false;
   AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, bounds);
   return true;
 }
 
 #if !defined(USE_ASH)
 void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
   DCHECK(default_bounds);
   DCHECK(monitor_info_provider_.get());
 
-  gfx::Rect work_area = monitor_info_provider_->GetPrimaryMonitorWorkArea();
+  gfx::Rect work_area = monitor_info_provider_->GetPrimaryDisplayWorkArea();
 
   // The default size is either some reasonably wide width, or if the work
   // area is narrower, then the work area width less some aesthetic padding.
   int default_width = std::min(work_area.width() - 2 * kWindowTilePixels, 1050);
   int default_height = work_area.height() - 2 * kWindowTilePixels;
 
   // For wider aspect ratio displays at higher resolutions, we might size the
   // window narrower to allow two windows to easily be placed side-by-side.
-  gfx::Rect screen_size = monitor_info_provider_->GetPrimaryMonitorBounds();
+  gfx::Rect screen_size = monitor_info_provider_->GetPrimaryDisplayBounds();
   double width_to_height =
     static_cast<double>(screen_size.width()) / screen_size.height();
 
   // The least wide a screen can be to qualify for the halving described above.
   static const int kMinScreenWidthForWindowHalving = 1600;
   // We assume 16:9/10 is a fairly standard indicator of a wide aspect ratio
   // computer display.
   if (((width_to_height * 10) >= 16) &&
       work_area.width() > kMinScreenWidthForWindowHalving) {
     // Halve the work area, subtracting aesthetic padding on either side.
@@ skipping 82 matching lines @@
 #endif  // defined(OS_MACOSX)
 }
 
 #if !defined(USE_ASH)
 bool WindowSizer::GetBoundsIgnoringPreviousState(
     const gfx::Rect& specified_bounds,
     gfx::Rect* bounds) const {
   return false;
 }
 #endif