Use gfx::Screen to provide display information in WindowSizer

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 "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/ash_init.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/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_switches.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:
-  explicit DefaultMonitorInfoProvider(const gfx::Screen* screen)
-      : screen_(screen) {}
-  // Overridden from MonitorInfoProvider:
-  virtual gfx::Rect GetPrimaryDisplayWorkArea() const OVERRIDE {
-    return screen_->GetPrimaryDisplay().work_area();
-  }
-  virtual gfx::Rect GetPrimaryDisplayBounds() const OVERRIDE {
-    return screen_->GetPrimaryDisplay().bounds();
-  }
-  virtual gfx::Rect GetMonitorWorkAreaMatching(
-      const gfx::Rect& match_rect) const OVERRIDE {
-    return screen_->GetDisplayMatching(match_rect).work_area();
-  }
- private:
-  const gfx::Screen* screen_;
-  DISALLOW_COPY_AND_ASSIGN(DefaultMonitorInfoProvider);
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 // 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) {
   }
 
   // Overridden from WindowSizer::StateProvider:
@@ skipping 99 matching lines @@
 // gets positioned to its default location.
 // static
 const int WindowSizer::kDesktopBorderSize = 16;
 
 // Maximum width of a window even if there is more room on the desktop.
 // static
 const int WindowSizer::kMaximumWindowWidth = 1100;
 
 WindowSizer::WindowSizer(StateProvider* state_provider, const Browser* browser)
     : state_provider_(state_provider),
-      monitor_info_provider_(new DefaultMonitorInfoProvider(
-          // TODO(scottmg): NativeScreen is wrong. http://crbug.com/133312
-          gfx::Screen::GetNativeScreen())),
+      // TODO(scottmg): NativeScreen is wrong. http://crbug.com/133312
+      screen_(gfx::Screen::GetNativeScreen()),
       browser_(browser) {
 }
 
 WindowSizer::WindowSizer(StateProvider* state_provider,
-                         MonitorInfoProvider* monitor_info_provider,
+                         gfx::Screen* screen,
                          const Browser* browser)
     : state_provider_(state_provider),
-      monitor_info_provider_(monitor_info_provider),
+      screen_(screen),
       browser_(browser) {
+  DCHECK(screen_);
 }
 
 WindowSizer::~WindowSizer() {
 }
 
 // static
 void WindowSizer::GetBrowserWindowBoundsAndShowState(
     const std::string& app_name,
     const gfx::Rect& specified_bounds,
     const Browser* browser,
@@ skipping 35 matching lines @@
     // No saved placement, figure out some sensible default size based on
     // the user's screen size.
     GetDefaultWindowBounds(bounds);
   } else {
     // In case that there was a bound given we need to make sure that it is
     // visible and fits on the screen.
     // Find the size of the work area of the monitor that intersects the bounds
     // of the anchor window. Note: AdjustBoundsToBeVisibleOnMonitorContaining
     // does not exactly what we want: It makes only sure that "a minimal part"
     // is visible on the screen.
-    gfx::Rect work_area =
-        monitor_info_provider_->GetMonitorWorkAreaMatching(*bounds);
+    gfx::Rect work_area = screen_->GetDisplayMatching(*bounds).work_area();
     // Resize so that it fits.
     bounds->AdjustToFit(work_area);
   }
 }
 
 bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds,
                                       ui::WindowShowState* show_state) const {
   DCHECK(bounds);
   DCHECK(show_state);
   if (!state_provider_.get() ||
@@ skipping 23 matching lines @@
 
 void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
 #if defined(USE_ASH)
   // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
   if (chrome::ShouldOpenAshOnStartup()) {
     GetDefaultWindowBoundsAsh(default_bounds);
     return;
   }
 #endif
   DCHECK(default_bounds);
-  DCHECK(monitor_info_provider_.get());
 
-  gfx::Rect work_area = monitor_info_provider_->GetPrimaryDisplayWorkArea();
+  gfx::Rect work_area = screen_->GetPrimaryDisplay().work_area();
 
   // 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_->GetPrimaryDisplayBounds();
+  gfx::Rect screen_size = screen_->GetPrimaryDisplay().bounds();
   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.
     // The padding is set so that two windows, side by side have
     // 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::AdjustBoundsToBeVisibleOnMonitorContaining(
     const gfx::Rect& other_bounds,
     const gfx::Rect& saved_work_area,
     gfx::Rect* bounds) const {
   DCHECK(bounds);
-  DCHECK(monitor_info_provider_.get());
 
   // Find the size of the work area of the monitor that intersects the bounds
   // of the anchor window.
-  gfx::Rect work_area =
-      monitor_info_provider_->GetMonitorWorkAreaMatching(other_bounds);
+  gfx::Rect work_area = screen_->GetDisplayMatching(other_bounds).work_area();
 
   // If height or width are 0, reset to the default size.
   gfx::Rect default_bounds;
   GetDefaultWindowBounds(&default_bounds);
   if (bounds->height() <= 0)
     bounds->set_height(default_bounds.height());
   if (bounds->width() <= 0)
     bounds->set_width(default_bounds.width());
 
   // Ensure the minimum height and width.
@@ skipping 68 matching lines @@
 
   if (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;
 }