Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / chrome / browser / ui / window_sizer / window_sizer_common_unittest.cc

diff --git a/src/chrome/browser/ui/window_sizer/window_sizer_common_unittest.cc b/src/chrome/browser/ui/window_sizer/window_sizer_common_unittest.cc
index 3c6c5ab..2c4c273 100644 (file)
--- a/src/chrome/browser/ui/window_sizer/window_sizer_common_unittest.cc
+++ b/src/chrome/browser/ui/window_sizer/window_sizer_common_unittest.cc
@@ -22,40 +22,31 @@ namespace {
 class TestScreen : public gfx::Screen {
  public:
   TestScreen() {}
-  virtual ~TestScreen() {}
+  ~TestScreen() override {}
 
   // Overridden from gfx::Screen:
-  virtual bool IsDIPEnabled() OVERRIDE {
-    NOTREACHED();
-    return false;
-  }
-
-  virtual gfx::Point GetCursorScreenPoint() OVERRIDE {
+  gfx::Point GetCursorScreenPoint() override {
     NOTREACHED();
     return gfx::Point();
   }
 
-  virtual gfx::NativeWindow GetWindowUnderCursor() OVERRIDE {
+  gfx::NativeWindow GetWindowUnderCursor() override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point)
-      OVERRIDE {
+  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual int GetNumDisplays() const OVERRIDE {
-    return displays_.size();
-  }
+  int GetNumDisplays() const override { return displays_.size(); }
 
-  virtual std::vector<gfx::Display> GetAllDisplays() const OVERRIDE {
+  std::vector<gfx::Display> GetAllDisplays() const override {
     return displays_;
   }
 
-  virtual gfx::Display GetDisplayNearestWindow(
-      gfx::NativeView view) const OVERRIDE {
+  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
 #if defined(USE_AURA)
     return GetDisplayMatching(view->GetBoundsInScreen());
 #else
@@ -64,14 +55,12 @@ class TestScreen : public gfx::Screen {
 #endif
   }
 
-  virtual gfx::Display GetDisplayNearestPoint(
-      const gfx::Point& point) const OVERRIDE {
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
     NOTREACHED();
     return gfx::Display();
   }
 
-  virtual gfx::Display GetDisplayMatching(
-      const gfx::Rect& match_rect) const OVERRIDE {
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
     int max_area = 0;
     size_t max_area_index = 0;
 
@@ -87,17 +76,11 @@ class TestScreen : public gfx::Screen {
     return displays_[max_area_index];
   }
 
-  virtual gfx::Display GetPrimaryDisplay() const OVERRIDE {
-    return displays_[0];
-  }
+  gfx::Display GetPrimaryDisplay() const override { return displays_[0]; }
 
-  virtual void AddObserver(gfx::DisplayObserver* observer) OVERRIDE {
-    NOTREACHED();
-  }
+  void AddObserver(gfx::DisplayObserver* observer) override { NOTREACHED(); }
 
-  virtual void RemoveObserver(gfx::DisplayObserver* observer) OVERRIDE {
-    NOTREACHED();
-  }
+  void RemoveObserver(gfx::DisplayObserver* observer) override { NOTREACHED(); }
 
   void AddDisplay(const gfx::Rect& bounds,
                   const gfx::Rect& work_area) {
@@ -112,6 +95,22 @@ class TestScreen : public gfx::Screen {
   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():
@@ -182,13 +181,15 @@ void GetWindowBoundsAndShowState(
   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.Pass(), tdp.Pass(), &test_screen, browser);
   sizer.DetermineWindowBoundsAndShowState(passed_in,
                                           out_bounds,
                                           out_show_state);
@@ -215,18 +216,19 @@ ui::WindowShowState GetWindowShowState(
     ui::WindowShowState show_state_last,
     Source source,
     const Browser* browser,
+    const gfx::Rect& bounds,
     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);
+    sp->SetPersistentState(bounds, display_config, 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.Pass(), tdp.Pass(), &test_screen, browser);
 
   ui::WindowShowState out_show_state = ui::SHOW_STATE_DEFAULT;
   gfx::Rect out_bounds;
@@ -238,7 +240,8 @@ ui::WindowShowState GetWindowShowState(
 }
 
 #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);