Use gfx::Screen to provide display information in WindowSizer

chrome/browser/ui/window_sizer/window_sizer_common_unittest.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_common_unittest.h"
 
 #include "ash/wm/window_resizer.h"
 #include "base/compiler_specific.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/screen.h"
 
-TestMonitorInfoProvider::TestMonitorInfoProvider() {};
+namespace {
 
-TestMonitorInfoProvider::~TestMonitorInfoProvider() {};
+class TestScreen : public gfx::Screen {
+ public:
+  TestScreen() {}
+  virtual ~TestScreen() {}
 
-void TestMonitorInfoProvider::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 gfx::Screen:
+  virtual bool IsDIPEnabled() OVERRIDE {
+    NOTREACHED();
+    return false;
+  }
 
-// Overridden from WindowSizer::MonitorInfoProvider:
-gfx::Rect TestMonitorInfoProvider::GetPrimaryDisplayWorkArea() const {
-  return work_areas_[0];
-}
+  virtual gfx::Point GetCursorScreenPoint() OVERRIDE {
+    NOTREACHED();
+    return gfx::Point();
+  }
 
-gfx::Rect TestMonitorInfoProvider::GetPrimaryDisplayBounds() const {
-  return monitor_bounds_[0];
-}
+  virtual gfx::NativeWindow GetWindowAtCursorScreenPoint() OVERRIDE {
+    NOTREACHED();
+    return NULL;
+  }
 
-gfx::Rect TestMonitorInfoProvider::GetMonitorWorkAreaMatching(
-    const gfx::Rect& match_rect) const {
-  return work_areas_[GetMonitorIndexMatchingBounds(match_rect)];
-}
+  virtual int GetNumDisplays() const OVERRIDE {
+    return displays_.size();
+  }
 
-size_t TestMonitorInfoProvider::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 = work_areas_[i];
-    overlap.Intersect(match_rect);
-    int area = overlap.width() * overlap.height();
-    if (area > max_area) {
-      max_area = area;
-      max_area_index = i;
+  virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
+    return displays_;
+  }
+
+  virtual gfx::Display GetDisplayNearestWindow(
+      gfx::NativeView view) const OVERRIDE {
+    NOTREACHED();
+    return gfx::Display();
+  }
+
+  virtual gfx::Display GetDisplayNearestPoint(
+      const gfx::Point& point) const OVERRIDE {
+    NOTREACHED();
+    return gfx::Display();
+  }
+
+  virtual gfx::Display GetDisplayMatching(
+      const gfx::Rect& match_rect) const OVERRIDE {
+    int max_area = 0;
+    size_t max_area_index = 0;
+
+    for (size_t i = 0; i < displays_.size(); ++i) {
+      gfx::Rect overlap = displays_[i].bounds();
+      overlap.Intersect(match_rect);
+      int area = overlap.width() * overlap.height();
+      if (area > max_area) {
+        max_area = area;
+        max_area_index = i;
+      }
     }
+    return displays_[max_area_index];
   }
-  return max_area_index;
-}
+
+  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
+    return displays_[0];
+  }
+
+  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {
+    NOTREACHED();
+  }
+
+  void AddDisplay(const gfx::Rect& bounds,
+                          const gfx::Rect& work_area) {
+    gfx::Display display(displays_.size(), bounds);
+    display.set_work_area(work_area);
+    displays_.push_back(display);
+  }
+
+ private:
+  std::vector<gfx::Display> displays_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestScreen);
+};
+
+}  // namespace
 
 TestStateProvider::TestStateProvider():
     has_persistent_data_(false),
     persistent_show_state_(ui::SHOW_STATE_DEFAULT),
     has_last_active_data_(false),
     last_active_show_state_(ui::SHOW_STATE_DEFAULT) {
 }
 
 void TestStateProvider::SetPersistentState(const gfx::Rect& bounds,
                                            const gfx::Rect& work_area,
@@ skipping 45 matching lines @@
     const gfx::Rect& bounds,
     const gfx::Rect& work_area,
     ui::WindowShowState show_state_persisted,
     ui::WindowShowState show_state_last,
     Source source,
     const Browser* browser,
     const gfx::Rect& passed_in,
     gfx::Rect* out_bounds,
     ui::WindowShowState* out_show_state) {
   DCHECK(out_show_state);
-  TestMonitorInfoProvider* mip = new TestMonitorInfoProvider;
-  mip->AddMonitor(monitor1_bounds, monitor1_work_area);
+  TestScreen test_screen;
+  test_screen.AddDisplay(monitor1_bounds, monitor1_work_area);
   if (!monitor2_bounds.IsEmpty())
-    mip->AddMonitor(monitor2_bounds, monitor2_bounds);
+    test_screen.AddDisplay(monitor2_bounds, monitor2_bounds);
   TestStateProvider* sp = new TestStateProvider;
   if (source == PERSISTED || source == BOTH)
     sp->SetPersistentState(bounds, work_area, show_state_persisted, true);
   if (source == LAST_ACTIVE || source == BOTH)
     sp->SetLastActiveState(bounds, show_state_last, true);
 
-  WindowSizer sizer(sp, mip, browser);
+  WindowSizer sizer(sp, &test_screen, browser);
   sizer.DetermineWindowBoundsAndShowState(passed_in,
                                           out_bounds,
                                           out_show_state);
 }
 
 void GetWindowBounds(const gfx::Rect& monitor1_bounds,
                             const gfx::Rect& monitor1_work_area,
                             const gfx::Rect& monitor2_bounds,
                             const gfx::Rect& bounds,
                             const gfx::Rect& work_area,
                             Source source,
                             const Browser* browser,
                             const gfx::Rect& passed_in,
                             gfx::Rect* out_bounds) {
   ui::WindowShowState out_show_state = ui::SHOW_STATE_DEFAULT;
   GetWindowBoundsAndShowState(
       monitor1_bounds, monitor1_work_area, monitor2_bounds, bounds, work_area,
       ui::SHOW_STATE_DEFAULT, ui::SHOW_STATE_DEFAULT, source, browser,
       passed_in, out_bounds, &out_show_state);
 }
 
 ui::WindowShowState GetWindowShowState(
     ui::WindowShowState show_state_persisted,
     ui::WindowShowState show_state_last,
     Source source,
     const Browser* browser,
     const gfx::Rect& display_config) {
   gfx::Rect bounds = display_config;
   gfx::Rect work_area = display_config;
-  TestMonitorInfoProvider* mip = new TestMonitorInfoProvider;
-  mip->AddMonitor(display_config, display_config);
+  TestScreen test_screen;
+  test_screen.AddDisplay(display_config, display_config);
   TestStateProvider* sp = new TestStateProvider;
   if (source == PERSISTED || source == BOTH)
     sp->SetPersistentState(bounds, work_area, show_state_persisted, true);
   if (source == LAST_ACTIVE || source == BOTH)
     sp->SetLastActiveState(bounds, show_state_last, true);
 
-  WindowSizer sizer(sp, mip, browser);
+  WindowSizer sizer(sp, &test_screen, browser);
 
   ui::WindowShowState out_show_state = ui::SHOW_STATE_DEFAULT;
   gfx::Rect out_bounds;
   sizer.DetermineWindowBoundsAndShowState(
       gfx::Rect(),
       &out_bounds,
       &out_show_state);
   return out_show_state;
 }
 
@@ skipping 199 matching lines @@
   { // Check that a window which hangs out of the screen get moved back in.
     gfx::Rect window_bounds;
     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(), gfx::Rect(),
                     gfx::Rect(), DEFAULT, NULL,
                     gfx::Rect(1020, 700, 100, 100), &window_bounds);
     EXPECT_EQ("924,668 100x100", window_bounds.ToString());
   }
 }
 
 #endif // defined(OS_MACOSX)