Extract MonitorInfoProvider from WindowSizer.

chrome/browser/ui/window_sizer_unittest.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 <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 25 matching lines @@
 // The work area for 1024x768 monitors with different taskbar orientations.
 static const gfx::Rect taskbar_bottom_work_area(0, 0, 1024, 734);
 static const gfx::Rect taskbar_top_work_area(0, 34, 1024, 734);
 static const gfx::Rect taskbar_left_work_area(107, 0, 917, 768);
 static const gfx::Rect taskbar_right_work_area(0, 0, 917, 768);
 
 static int kWindowTilePixels = WindowSizer::kWindowTilePixels;
 
 // Testing implementation of WindowSizer::MonitorInfoProvider that we can use
 // to fake various monitor layouts and sizes.
-class TestMonitorInfoProvider : public WindowSizer::MonitorInfoProvider {
+class TestMonitorInfoProvider : public MonitorInfoProvider {
  public:
   TestMonitorInfoProvider() {}
   virtual ~TestMonitorInfoProvider() {}
 
   void AddMonitor(const gfx::Rect& bounds, const gfx::Rect& work_area) {
     DCHECK(bounds.Contains(work_area));
     monitor_bounds_.push_back(bounds);
     work_areas_.push_back(work_area);
   }
 
   // Overridden from WindowSizer::MonitorInfoProvider:
   virtual gfx::Rect GetPrimaryMonitorWorkArea() const OVERRIDE {
     return work_areas_[0];
   }
 
   virtual gfx::Rect GetPrimaryMonitorBounds() const OVERRIDE {
     return monitor_bounds_[0];
   }
 
   virtual gfx::Rect GetMonitorWorkAreaMatching(
       const gfx::Rect& match_rect) const OVERRIDE {
     return work_areas_[GetMonitorIndexMatchingBounds(match_rect)];
   }
 
-  virtual void UpdateWorkAreas() OVERRIDE {}
-
  private:
   size_t GetMonitorIndexMatchingBounds(const gfx::Rect& match_rect) const {
     int max_area = 0;
     size_t max_area_index = 0;
     // Loop through all the monitors, finding the one that intersects the
     // largest area of the supplied match rect.
     for (size_t i = 0; i < work_areas_.size(); ++i) {
       gfx::Rect overlap(match_rect.Intersect(work_areas_[i]));
       int area = overlap.width() * overlap.height();
       if (area > max_area) {
         max_area = area;
         max_area_index = i;
       }
     }
     return max_area_index;
   }
 
   std::vector<gfx::Rect> monitor_bounds_;
+  std::vector<gfx::Rect> work_areas_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMonitorInfoProvider);
 };
 
 // Testing implementation of WindowSizer::StateProvider that we use to fake
 // persistent storage and existing windows.
 class TestStateProvider : public WindowSizer::StateProvider {
  public:
   TestStateProvider()
     : has_persistent_data_(false),
@@ skipping 728 matching lines @@
 
   { // entirely off bottom (monitor was detached since last run)
     gfx::Rect window_bounds;
     GetWindowBounds(tentwentyfour, tentwentyfour, gfx::Rect(),
                     gfx::Rect(50, 800, 500, 400), bottom_nonprimary,
                     PERSISTED, &window_bounds);
     EXPECT_EQ(gfx::Rect(50, 368, 500, 400), window_bounds);
   }
 }
 #endif  //defined(OS_MACOSX)