Make sure that 30%of restored window is always visible.

ash/wm/workspace/workspace_layout_manager_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 "ash/wm/workspace/workspace_layout_manager.h"
 
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
@@ skipping 44 matching lines @@
   // Make sure the unminimized window moves inside the display when
   // 2nd display is disconnected.
   wm::MinimizeWindow(window.get());
   UpdateDisplay("400x300");
   wm::RestoreWindow(window.get());
   EXPECT_EQ(Shell::GetPrimaryRootWindow(), window->GetRootWindow());
   EXPECT_TRUE(
       Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
 }
 
+TEST_F(WorkspaceLayoutManagerTest, KeepRestoredWindowInDisplay) {
+  scoped_ptr<aura::Window> window(
+      CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
+  // Maximized -> Normal transition.
+  wm::MaximizeWindow(window.get());
+  SetRestoreBoundsInScreen(window.get(), gfx::Rect(-100, -100, 30, 40));
+  wm::RestoreWindow(window.get());
+  EXPECT_TRUE(
+      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
+  EXPECT_EQ("-20,-30 30x40", window->bounds().ToString());
+
+  // Minimized -> Normal transition.
+  window->SetBounds(gfx::Rect(-100, -100, 30, 40));
+  wm::MinimizeWindow(window.get());
+  EXPECT_FALSE(
+      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
+  EXPECT_EQ("-100,-100 30x40", window->bounds().ToString());
+  window->Show();
+  EXPECT_TRUE(
+      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
+  EXPECT_EQ("-20,-30 30x40", window->bounds().ToString());
+
+  // Fullscreen -> Normal transition.
+  window->SetBounds(gfx::Rect(0, 0, 30, 40));  // reset bounds.
+  ASSERT_EQ("0,0 30x40", window->bounds().ToString());
+  window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
+  EXPECT_EQ(window->bounds(), window->GetRootWindow()->bounds());
+  SetRestoreBoundsInScreen(window.get(), gfx::Rect(-100, -100, 30, 40));
+  wm::RestoreWindow(window.get());
+  EXPECT_TRUE(
+      Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
+  EXPECT_EQ("-20,-30 30x40", window->bounds().ToString());
+}
+
 // WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
 // This code mirrors what BrowserFrameAura does. In particular when this code
 // sees the window was maximized it changes the bounds of a secondary
 // window. The secondary window mirrors the status window.
 class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
  public:
   DontClobberRestoreBoundsWindowObserver() : window_(NULL) {}
 
   void set_window(aura::Window* window) { window_ = window; }
 
@@ skipping 28 matching lines @@
   DontClobberRestoreBoundsWindowObserver window_observer;
   scoped_ptr<aura::Window> window(new aura::Window(NULL));
   window->SetType(aura::client::WINDOW_TYPE_NORMAL);
   window->Init(ui::LAYER_TEXTURED);
   window->SetBounds(gfx::Rect(10, 20, 30, 40));
   // NOTE: for this test to exercise the failure the observer needs to be added
   // before the parent set. This mimics what BrowserFrameAura does.
   window->AddObserver(&window_observer);
   SetDefaultParentByPrimaryRootWindow(window.get());
   window->Show();
-  ash::wm::ActivateWindow(window.get());
+  wm::ActivateWindow(window.get());
 
   scoped_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40)));
   window->AddTransientChild(window2.get());
   window2->Show();
 
   window_observer.set_window(window2.get());
   wm::MaximizeWindow(window.get());
   EXPECT_EQ("10,20 30x40", GetRestoreBoundsInScreen(window.get())->ToString());
   window->RemoveObserver(&window_observer);
 }
 
 // Verifies when a window is maximized all descendant windows have a size.
 TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(10, 20, 30, 40)));
   window->Show();
-  ash::wm::ActivateWindow(window.get());
+  wm::ActivateWindow(window.get());
   scoped_ptr<aura::Window> child_window(
       aura::test::CreateTestWindowWithBounds(gfx::Rect(5, 6, 7, 8),
                                              window.get()));
   child_window->Show();
-  ash::wm::MaximizeWindow(window.get());
+  wm::MaximizeWindow(window.get());
   EXPECT_EQ("5,6 7x8", child_window->bounds().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) {
   // Normal window bounds shouldn't be changed.
   gfx::Rect window_bounds(100, 100, 200, 200);
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(window_bounds, window->bounds());
 
   // If the window is out of the workspace, it would be moved on screen.
   gfx::Rect root_window_bounds =
-      ash::Shell::GetInstance()->GetPrimaryRootWindow()->bounds();
+      Shell::GetInstance()->GetPrimaryRootWindow()->bounds();
   window_bounds.Offset(root_window_bounds.width(), root_window_bounds.height());
   ASSERT_FALSE(window_bounds.Intersects(root_window_bounds));
   scoped_ptr<aura::Window> out_window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(window_bounds.size(), out_window->bounds().size());
   gfx::Rect bounds = out_window->bounds();
   bounds.Intersect(root_window_bounds);
-  // 2/3 of the window must be visible.
-  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.6);
-  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.6);
+
+  // 30% of the window edge must be visible.
+  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
+  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
+
+  // Make sure we always make more than 1/3 of the window edge visible even
+  // if the initial bounds intersects with display.
+  window_bounds.SetRect(-150, -150, 200, 200);
+  bounds = window_bounds;
+  bounds.Intersect(root_window_bounds);
+  EXPECT_LT(bounds.width(), out_window->bounds().width() * 0.29);

[James Cook, 2013/08/07 00:36:32]

Should these be EXPECT_LT(..., width * 0.3) instead of 0.29 ?

[oshima, 2013/08/07 16:56:45]

This is to make sure that the initial bounds is positioned
so that less than 30% is visible. I added comment and changed
to 0.26 to make it clear.

+  EXPECT_LT(bounds.height(), out_window->bounds().height() * 0.29);
+  ASSERT_TRUE(window_bounds.Intersects(root_window_bounds));
+
+  scoped_ptr<aura::Window> partially_out_window(
+      CreateTestWindowInShellWithBounds(window_bounds));
+  EXPECT_EQ(window_bounds.size(), partially_out_window->bounds().size());
+  bounds = partially_out_window->bounds();
+  bounds.Intersect(root_window_bounds);
+  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
+  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
+
+  // Make sure the window whose 30% width/height is bigger than display
+  // will be placed correctly.
+  window_bounds.SetRect(-1900, -1900, 3000, 3000);
+  scoped_ptr<aura::Window> window_bigger_than_display(
+      CreateTestWindowInShellWithBounds(window_bounds));
+  EXPECT_GE(root_window_bounds.width(),
+            window_bigger_than_display->bounds().width());
+  EXPECT_GE(root_window_bounds.height(),
+            window_bigger_than_display->bounds().height());
+
+  bounds = window_bigger_than_display->bounds();
+  bounds.Intersect(root_window_bounds);
+  EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29);
+  EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29);
 }
 
 // Verifies the size of a window is enforced to be smaller than the work area.
 TEST_F(WorkspaceLayoutManagerTest, SizeToWorkArea) {
   // Normal window bounds shouldn't be changed.
   gfx::Size work_area(
       Shell::GetScreen()->GetPrimaryDisplay().work_area().size());
   const gfx::Rect window_bounds(
       100, 101, work_area.width() + 1, work_area.height() + 2);
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(window_bounds));
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
       window->bounds().ToString());
 
   // Directly setting the bounds triggers a slightly different code path. Verify
   // that too.
   window->SetBounds(window_bounds);
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
       window->bounds().ToString());
 }
 
 }  // namespace
 }  // namespace ash