Extract MonitorInfoProvider from WindowSizer.

chrome/browser/ui/window_sizer.cc

 // Copyright (c) 2011 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::GetPrimaryMonitorWorkArea();
+  }
+  virtual gfx::Rect GetPrimaryMonitorBounds() const OVERRIDE {
+    return gfx::Screen::GetPrimaryMonitorBounds();
+  }
+  virtual gfx::Rect GetMonitorWorkAreaMatching(
+      const gfx::Rect& match_rect) const OVERRIDE {
+    return gfx::Screen::GetMonitorWorkAreaMatching(match_rect);
+  }
+};
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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 71 matching lines @@
   std::string app_name_;
 
   // If set, is used as the reference browser for GetLastActiveWindowState.
   const Browser* browser_;
   DISALLOW_COPY_AND_ASSIGN(DefaultStateProvider);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, public:
 
+WindowSizer::WindowSizer(StateProvider* state_provider)
+    : state_provider_(state_provider),
+      monitor_info_provider_(new DefaultMonitorInfoProvider) {
+}
+
 WindowSizer::WindowSizer(StateProvider* state_provider,
                          MonitorInfoProvider* monitor_info_provider)
     : state_provider_(state_provider),
       monitor_info_provider_(monitor_info_provider) {
 }
 
 WindowSizer::~WindowSizer() {
 }
 
 // static
 void WindowSizer::GetBrowserWindowBounds(const std::string& app_name,
                                          const gfx::Rect& specified_bounds,
                                          const Browser* browser,
                                          gfx::Rect* window_bounds) {
-  const WindowSizer sizer(new DefaultStateProvider(app_name, browser),
-                          CreateDefaultMonitorInfoProvider());
+  const WindowSizer sizer(new DefaultStateProvider(app_name, browser));
   sizer.DetermineWindowBounds(specified_bounds, window_bounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
 void WindowSizer::DetermineWindowBounds(const gfx::Rect& specified_bounds,
                                         gfx::Rect* bounds) const {
   *bounds = specified_bounds;
   if (bounds->IsEmpty()) {
@@ skipping 58 matching lines @@
     // 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);
 }
 
-bool WindowSizer::PositionIsOffscreen(int position, Edge edge) const {
-  DCHECK(monitor_info_provider_.get());
-  size_t monitor_count = monitor_info_provider_->GetMonitorCount();
-  for (size_t i = 0; i < monitor_count; ++i) {
-    gfx::Rect work_area = monitor_info_provider_->GetWorkAreaAt(i);
-    switch (edge) {
-      case TOP:
-        if (position >= work_area.y())
-          return false;
-        break;
-      case LEFT:
-        if (position >= work_area.x())
-          return false;
-        break;
-      case BOTTOM:
-        if (position <= work_area.bottom())
-          return false;
-        break;
-      case RIGHT:
-        if (position <= work_area.right())
-          return false;
-        break;
-    }
-  }
-  return true;
-}
-
-namespace {
-  // Minimum height of the visible part of a window.
-  static const int kMinVisibleHeight = 30;
-  // Minimum width of the visible part of a window.
-  static const int kMinVisibleWidth = 30;
-}
-
 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 =
@@ skipping 53 matching lines @@
   // On non-Mac platforms, we are less aggressive about repositioning.  Simply
   // 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)
 }