Removes aura dependencies from WindowPositioner

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 <stddef.h>
 #include <utility>
 
 #include "ash/wm/window_resizer.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "build/build_config.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"
 
 #if defined(USE_AURA)
 #include "ui/aura/window.h"
 #endif
 
 namespace {
 
 class TestScreen : public gfx::Screen {
  public:
-  TestScreen() {}
-  ~TestScreen() override {}
+  TestScreen() : previous_screen_(gfx::Screen::GetScreen()) {
+    gfx::Screen::SetScreenInstance(this);
+  }
+  ~TestScreen() override { gfx::Screen::SetScreenInstance(previous_screen_); }
+
+  // Sets the index of the display returned from GetDisplayNearestWindow().
+  // Only used on aura.
+  void set_index_of_display_nearest_window(int index) {
+    index_of_display_nearest_window_ = index;
+  }
 
   // Overridden from gfx::Screen:
   gfx::Point GetCursorScreenPoint() override {
     NOTREACHED();
     return gfx::Point();
   }
 
   gfx::NativeWindow GetWindowUnderCursor() override {
     NOTREACHED();
     return NULL;
   }
 
   gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
     NOTREACHED();
     return NULL;
   }
 
   int GetNumDisplays() const override { return displays_.size(); }
 
   std::vector<gfx::Display> GetAllDisplays() const override {
     return displays_;
   }
 
   gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
 #if defined(USE_AURA)
-    return GetDisplayMatching(view->GetBoundsInScreen());
+    return displays_[index_of_display_nearest_window_];
 #else
     NOTREACHED();
     return gfx::Display();
 #endif
   }
 
   gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
     NOTREACHED();
     return gfx::Display();
   }
@@ skipping 21 matching lines @@
   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:
+  gfx::Screen* previous_screen_;
+  size_t index_of_display_nearest_window_ = 0u;
   std::vector<gfx::Display> displays_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScreen);
 };
 
 class TestTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
 public:
   TestTargetDisplayProvider() {}
   ~TestTargetDisplayProvider() override {}
 
   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) {
-}
+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,
                                            ui::WindowShowState show_state,
                                            bool has_persistent_data) {
   persistent_bounds_ = bounds;
   persistent_work_area_ = work_area;
   persistent_show_state_ = show_state;
   has_persistent_data_ = has_persistent_data;
 }
@@ skipping 24 matching lines @@
   DCHECK(show_state);
   *bounds = last_active_bounds_;
   if (*show_state == ui::SHOW_STATE_DEFAULT)
     *show_state = last_active_show_state_;
   return has_last_active_data_;
 }
 
 int kWindowTilePixels = WindowSizer::kWindowTilePixels;
 
 // The window sizer commonly used test functions.
-void GetWindowBoundsAndShowState(
-    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,
-    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) {
+void GetWindowBoundsAndShowState(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,
+                                 ui::WindowShowState show_state_persisted,
+                                 ui::WindowShowState show_state_last,
+                                 Source source,
+                                 const Browser* browser,
+                                 const gfx::Rect& passed_in,
+                                 size_t display_index,
+                                 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);
+  test_screen.set_index_of_display_nearest_window(display_index);
   std::unique_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);
   std::unique_ptr<WindowSizer::TargetDisplayProvider> tdp(
       new TestTargetDisplayProvider);
 
   WindowSizer sizer(std::move(sp), std::move(tdp), &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);
+      passed_in, 0u, 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& bounds,
     const gfx::Rect& display_config) {
   TestScreen test_screen;
@@ skipping 220 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)