Open non browser window on the target display

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"
@@ skipping 94 matching lines @@
     display.set_work_area(work_area);
     displays_.push_back(display);
   }
 
  private:
   std::vector<gfx::Display> displays_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreen);
 };
 
+class TestTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
+public:
+  TestTargetDisplayProvider() {}
+  virtual ~TestTargetDisplayProvider() {}
+
+  virtual gfx::Display GetTargetDisplay(
+      const gfx::Screen* screen,
+      const gfx::Rect& bounds) const OVERRIDE {
+    // On ash, the bounds is used as a indicator to specify
+    // the target display.
+    return screen->GetDisplayMatching(bounds);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestTargetDisplayProvider);
+};
+
 }  // 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,
@@ skipping 50 matching lines @@
     Source source,
     const Browser* browser,
     const gfx::Rect& passed_in,
     gfx::Rect* out_bounds,
     ui::WindowShowState* out_show_state) {
   DCHECK(out_show_state);
   TestScreen test_screen;
   test_screen.AddDisplay(monitor1_bounds, monitor1_work_area);
   if (!monitor2_bounds.IsEmpty())
     test_screen.AddDisplay(monitor2_bounds, monitor2_bounds);
-  TestStateProvider* sp = new TestStateProvider;
+  scoped_ptr<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);
+  scoped_ptr<WindowSizer::TargetDisplayProvider> tdp(
+      new TestTargetDisplayProvider);
 
-  WindowSizer sizer(sp, &test_screen, browser);
+  WindowSizer sizer(sp.PassAs<WindowSizer::StateProvider>(),
+                    tdp.Pass(), &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,
@@ skipping 11 matching lines @@
 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;
   TestScreen test_screen;
   test_screen.AddDisplay(display_config, display_config);
-  TestStateProvider* sp = new TestStateProvider;
+  scoped_ptr<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);
+  scoped_ptr<WindowSizer::TargetDisplayProvider> tdp(
+      new TestTargetDisplayProvider);
 
-  WindowSizer sizer(sp, &test_screen, browser);
+  WindowSizer sizer(sp.PassAs<WindowSizer::StateProvider>(),
+                    tdp.Pass(), &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;
 }
 
 #if !defined(OS_MACOSX)
-TEST(WindowSizerTestCommon, PersistedWindowOffscreenWithNonAggressiveRepositioning) {
+TEST(WindowSizerTestCommon,
+     PersistedWindowOffscreenWithNonAggressiveRepositioning) {
   { // off the left but the minimum visibility condition is barely satisfied
     // without relocaiton.
     gfx::Rect initial_bounds(-470, 50, 500, 400);
 
     gfx::Rect window_bounds;
     GetWindowBounds(p1024x768, p1024x768, gfx::Rect(),
                     initial_bounds, gfx::Rect(), PERSISTED,
                     NULL, gfx::Rect(), &window_bounds);
     EXPECT_EQ(initial_bounds.ToString(), window_bounds.ToString());
   }
@@ skipping 187 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)