ash/wm/workspace/workspace_layout_manager_unittest.cc - platform/external/chromium_org - Git at Google

 // 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/display/display_layout.h"
 #include "ash/display/display_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"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/insets.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"

 namespace ash {
 namespace {

 class MaximizeDelegateView : public views::WidgetDelegateView {
  public:
   MaximizeDelegateView(const gfx::Rect& initial_bounds)
       : initial_bounds_(initial_bounds) {
   }
   virtual ~MaximizeDelegateView() {}

   virtual bool GetSavedWindowPlacement(
       gfx::Rect* bounds,
       ui::WindowShowState* show_state) const OVERRIDE {
     *bounds = initial_bounds_;
     *show_state = ui::SHOW_STATE_MAXIMIZED;
     return true;
   }

  private:
   const gfx::Rect initial_bounds_;

   DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
 };

 }  // namespace

 typedef test::AshTestBase WorkspaceLayoutManagerTest;

 // Verifies that a window containing a restore coordinate will be restored to
 // to the size prior to minimize, keeping the restore rectangle in tact (if
 // there is one).
 TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) {
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 3, 4)));
   gfx::Rect bounds(10, 15, 25, 35);
   window->SetBounds(bounds);

   wm::WindowState* window_state = wm::GetWindowState(window.get());

   // This will not be used for un-minimizing window.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
   window_state->Minimize();
   window_state->Restore();
   EXPECT_EQ("0,0 100x100", window_state->GetRestoreBoundsInScreen().ToString());
   EXPECT_EQ("10,15 25x35", window.get()->bounds().ToString());

   if (!SupportsMultipleDisplays())
     return;

   UpdateDisplay("400x300,500x400");
   window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100),
                             ScreenAsh::GetSecondaryDisplay());
   EXPECT_EQ(Shell::GetAllRootWindows()[1], window->GetRootWindow());
   window_state->Minimize();
   // This will not be used for un-minimizing window.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
   window_state->Restore();
   EXPECT_EQ("600,0 100x100", window->GetBoundsInScreen().ToString());

   // Make sure the unminimized window moves inside the display when
   // 2nd display is disconnected.
   window_state->Minimize();
   UpdateDisplay("400x300");
   window_state->Restore();
   EXPECT_EQ(Shell::GetPrimaryRootWindow(), window->GetRootWindow());
   EXPECT_TRUE(
       Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
 }

 TEST_F(WorkspaceLayoutManagerTest, KeepMinimumVisibilityInDisplays) {
   if (!SupportsMultipleDisplays())
     return;

   UpdateDisplay("300x400,400x500");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

   DisplayLayout layout(DisplayLayout::TOP, 0);
   Shell::GetInstance()->display_manager()->
       SetLayoutForCurrentDisplays(layout);
   EXPECT_EQ("0,-500 400x500", root_windows[1]->GetBoundsInScreen().ToString());

   scoped_ptr<aura::Window> window1(
       CreateTestWindowInShellWithBounds(gfx::Rect(10, -400, 200, 200)));
   EXPECT_EQ("10,-400 200x200", window1->GetBoundsInScreen().ToString());

   // Make sure the caption is visible.
   scoped_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(10, -600, 200, 200)));
   EXPECT_EQ("10,-500 200x200", window2->GetBoundsInScreen().ToString());
 }

 TEST_F(WorkspaceLayoutManagerTest, KeepRestoredWindowInDisplay) {
   if (!SupportsHostWindowResize())
     return;
   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   wm::WindowState* window_state = wm::GetWindowState(window.get());

   // Maximized -> Normal transition.
   window_state->Maximize();
   window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
   window_state->Restore();
   EXPECT_TRUE(
       Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
   // Y bounds should not be negative.
   EXPECT_EQ("-20,0 30x40", window->bounds().ToString());

   // Minimized -> Normal transition.
   window->SetBounds(gfx::Rect(-100, -100, 30, 40));
   window_state->Minimize();
   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()));
   // Y bounds should not be negative.
   EXPECT_EQ("-20,0 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());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
   window_state->Restore();
   EXPECT_TRUE(
       Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
   // Y bounds should not be negative.
   EXPECT_EQ("-20,0 30x40", window->bounds().ToString());
 }

 TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("300x400,400x500");

   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   EXPECT_EQ(root_windows[0], window->GetRootWindow());

   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
   // Maximize the window in 2nd display as the restore bounds
   // is inside 2nd display.
   window_state->Maximize();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());

   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());

   // If the restore bounds intersects with the current display,
   // don't move.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
   window_state->Maximize();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());

   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());

   // Restoring widget state.
   scoped_ptr<views::Widget> w1(new views::Widget);
   views::Widget::InitParams params;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = new MaximizeDelegateView(gfx::Rect(400, 0, 30, 40));
   params.context = root_windows[0];
   w1->Init(params);
   w1->Show();
   EXPECT_TRUE(w1->IsMaximized());
   EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
   EXPECT_EQ("300,0 400x453", w1->GetWindowBoundsInScreen().ToString());
   w1->Restore();
   EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
   EXPECT_EQ("400,0 30x40", w1->GetWindowBoundsInScreen().ToString());
 }

 TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("300x400,400x500");

   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

   scoped_ptr<aura::Window> window(
       CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
   EXPECT_EQ(root_windows[0], window->GetRootWindow());

   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
   // Maximize the window in 2nd display as the restore bounds
   // is inside 2nd display.
   window->SetProperty(aura::client::kShowStateKey,
                       ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());

   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());

   // If the restore bounds intersects with the current display,
   // don't move.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
   window->SetProperty(aura::client::kShowStateKey,
                       ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());

   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());
 }

 // WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
 // This code mirrors what BrowserFrameAsh 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; }

   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
                                        intptr_t old) OVERRIDE {
     if (!window_)
       return;

     if (wm::GetWindowState(window)->IsMaximized()) {
       aura::Window* w = window_;
       window_ = NULL;

       gfx::Rect shelf_bounds(Shell::GetPrimaryRootWindowController()->
                              GetShelfLayoutManager()->GetIdealBounds());
       const gfx::Rect& window_bounds(w->bounds());
       w->SetBounds(gfx::Rect(window_bounds.x(), shelf_bounds.y() - 1,
                              window_bounds.width(), window_bounds.height()));
     }
   }

  private:
   aura::Window* window_;

   DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver);
 };

 // Creates a window, maximized the window and from within the maximized
 // notification sets the bounds of a window to overlap the shelf. Verifies this
 // doesn't effect the restore bounds.
 TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) {
   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 BrowserFrameAsh does.
   window->AddObserver(&window_observer);
   ParentWindowInPrimaryRootWindow(window.get());
   window->Show();

   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();

   scoped_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40)));
   window->AddTransientChild(window2.get());
   window2->Show();

   window_observer.set_window(window2.get());
   window_state->Maximize();
   EXPECT_EQ("10,20 30x40",
             window_state->GetRestoreBoundsInScreen().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();
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   window_state->Activate();
   scoped_ptr<aura::Window> child_window(
       aura::test::CreateTestWindowWithBounds(gfx::Rect(5, 6, 7, 8),
                                              window.get()));
   child_window->Show();
   window_state->Maximize();
   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 =
       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);

   // 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);

   aura::Window* parent = out_window->parent();
   parent->RemoveChild(out_window.get());
   out_window->SetBounds(gfx::Rect(-200, -200, 200, 200));
   // UserHasChangedWindowPositionOrSize flag shouldn't turn off this behavior.
   wm::GetWindowState(window.get())->set_bounds_changed_by_user(true);
   parent->AddChild(out_window.get());
   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);

   // Make sure that the initial bounds' visible area is less than 26%
   // so that the auto adjustment logic kicks in.
   ASSERT_LT(bounds.width(), out_window->bounds().width() * 0.26);
   ASSERT_LT(bounds.height(), out_window->bounds().height() * 0.26);
   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 ash
	// 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/display/display_layout.h"
	#include "ash/display/display_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"
	#include "ash/shell.h"
	#include "ash/test/ash_test_base.h"
	#include "ash/wm/window_state.h"
	#include "ash/wm/window_util.h"
	#include "ui/aura/client/aura_constants.h"
	#include "ui/aura/root_window.h"
	#include "ui/aura/test/test_windows.h"
	#include "ui/aura/window.h"
	#include "ui/gfx/insets.h"
	#include "ui/views/widget/widget.h"
	#include "ui/views/widget/widget_delegate.h"

	namespace ash {
	namespace {

	class MaximizeDelegateView : public views::WidgetDelegateView {
	public:
	MaximizeDelegateView(const gfx::Rect& initial_bounds)
	: initial_bounds_(initial_bounds) {
	}
	virtual ~MaximizeDelegateView() {}

	virtual bool GetSavedWindowPlacement(
	gfx::Rect* bounds,
	ui::WindowShowState* show_state) const OVERRIDE {
	*bounds = initial_bounds_;
	*show_state = ui::SHOW_STATE_MAXIMIZED;
	return true;
	}

	private:
	const gfx::Rect initial_bounds_;

	DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
	};

	} // namespace

	typedef test::AshTestBase WorkspaceLayoutManagerTest;

	// Verifies that a window containing a restore coordinate will be restored to
	// to the size prior to minimize, keeping the restore rectangle in tact (if
	// there is one).
	TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) {
	scoped_ptr<aura::Window> window(
	CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 3, 4)));
	gfx::Rect bounds(10, 15, 25, 35);
	window->SetBounds(bounds);

	wm::WindowState* window_state = wm::GetWindowState(window.get());

	// This will not be used for un-minimizing window.
	window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
	window_state->Minimize();
	window_state->Restore();
	EXPECT_EQ("0,0 100x100", window_state->GetRestoreBoundsInScreen().ToString());
	EXPECT_EQ("10,15 25x35", window.get()->bounds().ToString());

	if (!SupportsMultipleDisplays())
	return;

	UpdateDisplay("400x300,500x400");
	window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100),
	ScreenAsh::GetSecondaryDisplay());
	EXPECT_EQ(Shell::GetAllRootWindows()[1], window->GetRootWindow());
	window_state->Minimize();
	// This will not be used for un-minimizing window.
	window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
	window_state->Restore();
	EXPECT_EQ("600,0 100x100", window->GetBoundsInScreen().ToString());

	// Make sure the unminimized window moves inside the display when
	// 2nd display is disconnected.
	window_state->Minimize();
	UpdateDisplay("400x300");
	window_state->Restore();
	EXPECT_EQ(Shell::GetPrimaryRootWindow(), window->GetRootWindow());
	EXPECT_TRUE(
	Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
	}

	TEST_F(WorkspaceLayoutManagerTest, KeepMinimumVisibilityInDisplays) {
	if (!SupportsMultipleDisplays())
	return;

	UpdateDisplay("300x400,400x500");
	Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

	DisplayLayout layout(DisplayLayout::TOP, 0);
	Shell::GetInstance()->display_manager()->
	SetLayoutForCurrentDisplays(layout);
	EXPECT_EQ("0,-500 400x500", root_windows[1]->GetBoundsInScreen().ToString());

	scoped_ptr<aura::Window> window1(
	CreateTestWindowInShellWithBounds(gfx::Rect(10, -400, 200, 200)));
	EXPECT_EQ("10,-400 200x200", window1->GetBoundsInScreen().ToString());

	// Make sure the caption is visible.
	scoped_ptr<aura::Window> window2(
	CreateTestWindowInShellWithBounds(gfx::Rect(10, -600, 200, 200)));
	EXPECT_EQ("10,-500 200x200", window2->GetBoundsInScreen().ToString());
	}

	TEST_F(WorkspaceLayoutManagerTest, KeepRestoredWindowInDisplay) {
	if (!SupportsHostWindowResize())
	return;
	scoped_ptr<aura::Window> window(
	CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
	wm::WindowState* window_state = wm::GetWindowState(window.get());

	// Maximized -> Normal transition.
	window_state->Maximize();
	window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
	window_state->Restore();
	EXPECT_TRUE(
	Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
	// Y bounds should not be negative.
	EXPECT_EQ("-20,0 30x40", window->bounds().ToString());

	// Minimized -> Normal transition.
	window->SetBounds(gfx::Rect(-100, -100, 30, 40));
	window_state->Minimize();
	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()));
	// Y bounds should not be negative.
	EXPECT_EQ("-20,0 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());
	window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40));
	window_state->Restore();
	EXPECT_TRUE(
	Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds()));
	// Y bounds should not be negative.
	EXPECT_EQ("-20,0 30x40", window->bounds().ToString());
	}

	TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) {
	if (!SupportsMultipleDisplays())
	return;
	UpdateDisplay("300x400,400x500");

	Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

	scoped_ptr<aura::Window> window(
	CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
	EXPECT_EQ(root_windows[0], window->GetRootWindow());

	wm::WindowState* window_state = wm::GetWindowState(window.get());
	window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
	// Maximize the window in 2nd display as the restore bounds
	// is inside 2nd display.
	window_state->Maximize();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());

	window_state->Restore();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());

	// If the restore bounds intersects with the current display,
	// don't move.
	window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
	window_state->Maximize();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("300,0 400x453", window->GetBoundsInScreen().ToString());

	window_state->Restore();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());

	// Restoring widget state.
	scoped_ptr<views::Widget> w1(new views::Widget);
	views::Widget::InitParams params;
	params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
	params.delegate = new MaximizeDelegateView(gfx::Rect(400, 0, 30, 40));
	params.context = root_windows[0];
	w1->Init(params);
	w1->Show();
	EXPECT_TRUE(w1->IsMaximized());
	EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
	EXPECT_EQ("300,0 400x453", w1->GetWindowBoundsInScreen().ToString());
	w1->Restore();
	EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow());
	EXPECT_EQ("400,0 30x40", w1->GetWindowBoundsInScreen().ToString());
	}

	TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) {
	if (!SupportsMultipleDisplays())
	return;
	UpdateDisplay("300x400,400x500");

	Shell::RootWindowList root_windows = Shell::GetAllRootWindows();

	scoped_ptr<aura::Window> window(
	CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40)));
	EXPECT_EQ(root_windows[0], window->GetRootWindow());

	wm::WindowState* window_state = wm::GetWindowState(window.get());
	window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40));
	// Maximize the window in 2nd display as the restore bounds
	// is inside 2nd display.
	window->SetProperty(aura::client::kShowStateKey,
	ui::SHOW_STATE_FULLSCREEN);
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());

	window_state->Restore();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("400,0 30x40", window->GetBoundsInScreen().ToString());

	// If the restore bounds intersects with the current display,
	// don't move.
	window_state->SetRestoreBoundsInScreen(gfx::Rect(280, 0, 30, 40));
	window->SetProperty(aura::client::kShowStateKey,
	ui::SHOW_STATE_FULLSCREEN);
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());

	window_state->Restore();
	EXPECT_EQ(root_windows[1], window->GetRootWindow());
	EXPECT_EQ("280,0 30x40", window->GetBoundsInScreen().ToString());
	}

	// WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver.
	// This code mirrors what BrowserFrameAsh 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; }

	virtual void OnWindowPropertyChanged(aura::Window* window,
	const void* key,
	intptr_t old) OVERRIDE {
	if (!window_)
	return;

	if (wm::GetWindowState(window)->IsMaximized()) {
	aura::Window* w = window_;
	window_ = NULL;

	gfx::Rect shelf_bounds(Shell::GetPrimaryRootWindowController()->
	GetShelfLayoutManager()->GetIdealBounds());
	const gfx::Rect& window_bounds(w->bounds());
	w->SetBounds(gfx::Rect(window_bounds.x(), shelf_bounds.y() - 1,
	window_bounds.width(), window_bounds.height()));
	}
	}

	private:
	aura::Window* window_;

	DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver);
	};

	// Creates a window, maximized the window and from within the maximized
	// notification sets the bounds of a window to overlap the shelf. Verifies this
	// doesn't effect the restore bounds.
	TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) {
	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 BrowserFrameAsh does.
	window->AddObserver(&window_observer);
	ParentWindowInPrimaryRootWindow(window.get());
	window->Show();

	wm::WindowState* window_state = wm::GetWindowState(window.get());
	window_state->Activate();

	scoped_ptr<aura::Window> window2(
	CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40)));
	window->AddTransientChild(window2.get());
	window2->Show();

	window_observer.set_window(window2.get());
	window_state->Maximize();
	EXPECT_EQ("10,20 30x40",
	window_state->GetRestoreBoundsInScreen().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();
	wm::WindowState* window_state = wm::GetWindowState(window.get());
	window_state->Activate();
	scoped_ptr<aura::Window> child_window(
	aura::test::CreateTestWindowWithBounds(gfx::Rect(5, 6, 7, 8),
	window.get()));
	child_window->Show();
	window_state->Maximize();
	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 =
	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);

	// 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);

	aura::Window* parent = out_window->parent();
	parent->RemoveChild(out_window.get());
	out_window->SetBounds(gfx::Rect(-200, -200, 200, 200));
	// UserHasChangedWindowPositionOrSize flag shouldn't turn off this behavior.
	wm::GetWindowState(window.get())->set_bounds_changed_by_user(true);
	parent->AddChild(out_window.get());
	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);

	// Make sure that the initial bounds' visible area is less than 26%
	// so that the auto adjustment logic kicks in.
	ASSERT_LT(bounds.width(), out_window->bounds().width() * 0.26);
	ASSERT_LT(bounds.height(), out_window->bounds().height() * 0.26);
	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 ash