Extract MonitorInfoProvider from WindowSizer.

chrome/browser/ui/window_sizer.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_WINDOW_SIZER_H_
 #define CHROME_BROWSER_UI_WINDOW_SIZER_H_
 #pragma once
 
-#include <vector>
-
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/rect.h"
 
 class Browser;
 
+// An interface implemented by an object that can retrieve information about
+// the monitors on the system.
+class MonitorInfoProvider {
+ public:
+  virtual ~MonitorInfoProvider() {}
+
+  // Returns the bounds of the work area of the primary monitor.
+  virtual gfx::Rect GetPrimaryMonitorWorkArea() const = 0;
+
+  // Returns the bounds of the primary monitor.
+  virtual gfx::Rect GetPrimaryMonitorBounds() const = 0;
+
+  // Returns the bounds of the work area of the monitor that most closely
+  // intersects the provided bounds.
+  virtual gfx::Rect GetMonitorWorkAreaMatching(
+      const gfx::Rect& match_rect) const = 0;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // 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 MonitorInfoProvider;
   class StateProvider;
 
-  // The WindowSizer assumes ownership of these objects.
+  // WindowSizer owns |state_provider| and |monitor_info_provider|.

[Ben Goodger (Google), 2011/12/07 17:17:35]

Also add this comment for the first function:

WindowSizer will create a default MonitorInfoProvider using the physical screen.

And for the second:

WindowSizer will use the supplied monitor info provider. Used for testing.

+  explicit WindowSizer(StateProvider* state_provider);
   WindowSizer(StateProvider* state_provider,
               MonitorInfoProvider* monitor_info_provider);
   virtual ~WindowSizer();
 
-  // Static factory methods to create default MonitorInfoProvider
-  // instances.  The returned object is owned by the caller.
-  static MonitorInfoProvider* CreateDefaultMonitorInfoProvider();
-
-  // An interface implemented by an object that can retrieve information about
-  // the monitors on the system.
-  class MonitorInfoProvider {
-   public:
-    MonitorInfoProvider() {}
-    virtual ~MonitorInfoProvider() {}
-
-    // Returns the bounds of the work area of the primary monitor.
-    virtual gfx::Rect GetPrimaryMonitorWorkArea() const = 0;
-
-    // Returns the bounds of the primary monitor.
-    virtual gfx::Rect GetPrimaryMonitorBounds() const = 0;
-
-    // Returns the bounds of the work area of the monitor that most closely
-    // intersects the provided bounds.
-    virtual gfx::Rect GetMonitorWorkAreaMatching(
-        const gfx::Rect& match_rect) const = 0;
-
-    // Ensures number and coordinates of work areas are up-to-date.  You must
-    // call this before calling either of the below functions, as work areas can
-    // change while the program is running.
-    virtual void UpdateWorkAreas() = 0;
-
-    // Returns the number of monitors on the system.
-    size_t GetMonitorCount() const {
-      return work_areas_.size();
-    }
-
-    // Returns the bounds of the work area of the monitor at the specified
-    // index.
-    gfx::Rect GetWorkAreaAt(size_t index) const {
-      return work_areas_[index];
-    }
-
-   protected:
-    std::vector<gfx::Rect> work_areas_;
-  };
-
   // An interface implemented by an object that can retrieve state from either a
   // persistent store or an existing window.
   class StateProvider {
    public:
     virtual ~StateProvider() {}
 
     // Retrieve the persisted bounds of the window. Returns true if there was
     // persisted data to retrieve state information, false otherwise.
     virtual bool GetPersistentState(gfx::Rect* bounds,
                                     gfx::Rect* work_area) const = 0;
@@ skipping 43 matching lines @@
   // in local state preferences. Returns true if local state exists containing
   // this information, false if this information does not exist and a default
   // size should be used.
   bool GetSavedWindowBounds(gfx::Rect* bounds) const;
 
   // Gets the default window position and size 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(gfx::Rect* default_bounds) const;
 
-  // Returns true if the specified position is "offscreen" for the given edge,
-  // meaning that it's outside all work areas in the direction of that edge.
-  bool PositionIsOffscreen(int position, Edge edge) const;
-
   // Adjusts |bounds| to be visible onscreen, biased toward the work area of the
   // monitor containing |other_bounds|.  Despite the name, this doesn't
   // guarantee the bounds are fully contained within this monitor'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 cofiguration has changed. If it has, bounds are repositioned and
   // resized if necessary to make them completely contained in the current work
   // area.
   void AdjustBoundsToBeVisibleOnMonitorContaining(
       const gfx::Rect& other_bounds,
       const gfx::Rect& saved_work_area,
       gfx::Rect* bounds) const;
 
   // Providers for persistent storage and monitor metrics.
   scoped_ptr<StateProvider> state_provider_;
   scoped_ptr<MonitorInfoProvider> monitor_info_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSizer);
 };
 
 #endif  // CHROME_BROWSER_UI_WINDOW_SIZER_H_