src/ash/shelf/shelf_layout_manager_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/shelf/shelf_layout_manager.h"
   6
   7 #include "ash/accelerators/accelerator_controller.h"
   8 #include "ash/accelerators/accelerator_table.h"
   9 #include "ash/ash_switches.h"
  10 #include "ash/display/display_manager.h"
  11 #include "ash/focus_cycler.h"
  12 #include "ash/root_window_controller.h"
  13 #include "ash/session/session_state_delegate.h"
  14 #include "ash/shelf/shelf.h"
  15 #include "ash/shelf/shelf_layout_manager_observer.h"
  16 #include "ash/shelf/shelf_view.h"
  17 #include "ash/shelf/shelf_widget.h"
  18 #include "ash/shell.h"
  19 #include "ash/shell_window_ids.h"
  20 #include "ash/system/status_area_widget.h"
  21 #include "ash/system/tray/system_tray.h"
  22 #include "ash/system/tray/system_tray_item.h"
  23 #include "ash/test/ash_test_base.h"
  24 #include "ash/test/shelf_test_api.h"
  25 #include "ash/wm/window_state.h"
  26 #include "ash/wm/window_util.h"
  27 #include "base/command_line.h"
  28 #include "base/strings/utf_string_conversions.h"
  29 #include "ui/aura/client/aura_constants.h"
  30 #include "ui/aura/window.h"
  31 #include "ui/aura/window_event_dispatcher.h"
  32 #include "ui/compositor/layer.h"
  33 #include "ui/compositor/layer_animator.h"
  34 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  35 #include "ui/events/gestures/gesture_configuration.h"
  36 #include "ui/events/test/event_generator.h"
  37 #include "ui/gfx/display.h"
  38 #include "ui/gfx/screen.h"
  39 #include "ui/views/controls/label.h"
  40 #include "ui/views/layout/fill_layout.h"
  41 #include "ui/views/view.h"
  42 #include "ui/views/widget/widget.h"
  43
  44 #if defined(OS_WIN)
  45 #include "base/win/windows_version.h"
  46 #endif
  47
  48 namespace ash {
  49 namespace {
  50
  51 void StepWidgetLayerAnimatorToEnd(views::Widget* widget) {
  52   widget->GetNativeView()->layer()->GetAnimator()->Step(
  53       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(1));
  54 }
  55
  56 ShelfWidget* GetShelfWidget() {
  57   return Shell::GetPrimaryRootWindowController()->shelf();
  58 }
  59
  60 ShelfLayoutManager* GetShelfLayoutManager() {
  61   return Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager();
  62 }
  63
  64 SystemTray* GetSystemTray() {
  65   return Shell::GetPrimaryRootWindowController()->GetSystemTray();
  66 }
  67
  68 // Class which waits till the shelf finishes animating to the target size and
  69 // counts the number of animation steps.
  70 class ShelfAnimationWaiter : views::WidgetObserver {
  71  public:
  72   explicit ShelfAnimationWaiter(const gfx::Rect& target_bounds)
  73       : target_bounds_(target_bounds),
  74         animation_steps_(0),
  75         done_waiting_(false) {
  76     GetShelfWidget()->AddObserver(this);
  77   }
  78
  79   virtual ~ShelfAnimationWaiter() {
  80     GetShelfWidget()->RemoveObserver(this);
  81   }
  82
  83   // Wait till the shelf finishes animating to its expected bounds.
  84   void WaitTillDoneAnimating() {
  85     if (IsDoneAnimating())
  86       done_waiting_ = true;
  87     else
  88       base::MessageLoop::current()->Run();
  89   }
  90
  91   // Returns true if the animation has completed and it was valid.
  92   bool WasValidAnimation() const {
  93     return done_waiting_ && animation_steps_ > 0;
  94   }
  95
  96  private:
  97   // Returns true if shelf has finished animating to the target size.
  98   bool IsDoneAnimating() const {
  99     ShelfLayoutManager* layout_manager = GetShelfLayoutManager();
 100     gfx::Rect current_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
 101     int size = layout_manager->PrimaryAxisValue(current_bounds.height(),
 102         current_bounds.width());
 103     int desired_size = layout_manager->PrimaryAxisValue(target_bounds_.height(),
 104         target_bounds_.width());
 105     return (size == desired_size);
 106   }
 107
 108   // views::WidgetObserver override.
 109   virtual void OnWidgetBoundsChanged(views::Widget* widget,
 110                                      const gfx::Rect& new_bounds) OVERRIDE {
 111     if (done_waiting_)
 112       return;
 113
 114     ++animation_steps_;
 115     if (IsDoneAnimating()) {
 116       done_waiting_ = true;
 117       base::MessageLoop::current()->Quit();
 118     }
 119   }
 120
 121   gfx::Rect target_bounds_;
 122   int animation_steps_;
 123   bool done_waiting_;
 124
 125   DISALLOW_COPY_AND_ASSIGN(ShelfAnimationWaiter);
 126 };
 127
 128 class ShelfDragCallback {
 129  public:
 130   ShelfDragCallback(const gfx::Rect& not_visible, const gfx::Rect& visible)
 131       : not_visible_bounds_(not_visible),
 132         visible_bounds_(visible),
 133         was_visible_on_drag_start_(false) {
 134     EXPECT_EQ(not_visible_bounds_.bottom(), visible_bounds_.bottom());
 135   }
 136
 137   virtual ~ShelfDragCallback() {
 138   }
 139
 140   void ProcessScroll(ui::EventType type, const gfx::Vector2dF& delta) {
 141     if (GetShelfLayoutManager()->visibility_state() == ash::SHELF_HIDDEN)
 142       return;
 143
 144     if (type == ui::ET_GESTURE_SCROLL_BEGIN) {
 145       scroll_ = gfx::Vector2dF();
 146       was_visible_on_drag_start_ = GetShelfLayoutManager()->IsVisible();
 147       return;
 148     }
 149
 150     // The state of the shelf at the end of the gesture is tested separately.
 151     if (type == ui::ET_GESTURE_SCROLL_END)
 152       return;
 153
 154     if (type == ui::ET_GESTURE_SCROLL_UPDATE)
 155       scroll_.Add(delta);
 156
 157     gfx::Rect shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
 158     if (GetShelfLayoutManager()->IsHorizontalAlignment()) {
 159       EXPECT_EQ(not_visible_bounds_.bottom(), shelf_bounds.bottom());
 160       EXPECT_EQ(visible_bounds_.bottom(), shelf_bounds.bottom());
 161     } else if (SHELF_ALIGNMENT_RIGHT ==
 162         GetShelfLayoutManager()->GetAlignment()){
 163       EXPECT_EQ(not_visible_bounds_.right(), shelf_bounds.right());
 164       EXPECT_EQ(visible_bounds_.right(), shelf_bounds.right());
 165     } else if (SHELF_ALIGNMENT_LEFT ==
 166         GetShelfLayoutManager()->GetAlignment()) {
 167       EXPECT_EQ(not_visible_bounds_.x(), shelf_bounds.x());
 168       EXPECT_EQ(visible_bounds_.x(), shelf_bounds.x());
 169     }
 170
 171     // if the shelf is being dimmed test dimmer bounds as well.
 172     if (GetShelfWidget()->GetDimsShelf())
 173       EXPECT_EQ(GetShelfWidget()->GetWindowBoundsInScreen(),
 174                 GetShelfWidget()->GetDimmerBoundsForTest());
 175
 176     // The shelf should never be smaller than the hidden state.
 177     EXPECT_GE(shelf_bounds.height(), not_visible_bounds_.height());
 178     float scroll_delta = GetShelfLayoutManager()->PrimaryAxisValue(
 179         scroll_.y(),
 180         scroll_.x());
 181     bool increasing_drag =
 182         GetShelfLayoutManager()->SelectValueForShelfAlignment(
 183             scroll_delta < 0,
 184             scroll_delta > 0,
 185             scroll_delta < 0,
 186             scroll_delta > 0);
 187     int shelf_size = GetShelfLayoutManager()->PrimaryAxisValue(
 188         shelf_bounds.height(),
 189         shelf_bounds.width());
 190     int visible_bounds_size = GetShelfLayoutManager()->PrimaryAxisValue(
 191         visible_bounds_.height(),
 192         visible_bounds_.width());
 193     int not_visible_bounds_size = GetShelfLayoutManager()->PrimaryAxisValue(
 194         not_visible_bounds_.height(),
 195         not_visible_bounds_.width());
 196     if (was_visible_on_drag_start_) {
 197       if (increasing_drag) {
 198         // If dragging inwards from the visible state, then the shelf should
 199         // increase in size, but not more than the scroll delta.
 200         EXPECT_LE(visible_bounds_size, shelf_size);
 201         EXPECT_LE(std::abs(shelf_size - visible_bounds_size),
 202                   std::abs(scroll_delta));
 203       } else {
 204         if (shelf_size > not_visible_bounds_size) {
 205           // If dragging outwards from the visible state, then the shelf
 206           // should decrease in size, until it reaches the minimum size.
 207           EXPECT_EQ(shelf_size, visible_bounds_size - std::abs(scroll_delta));
 208         }
 209       }
 210     } else {
 211       if (std::abs(scroll_delta) <
 212           visible_bounds_size - not_visible_bounds_size) {
 213         // Tests that the shelf sticks with the touch point during the drag
 214         // until the shelf is completely visible.
 215         EXPECT_EQ(shelf_size, not_visible_bounds_size + std::abs(scroll_delta));
 216       } else {
 217         // Tests that after the shelf is completely visible, the shelf starts
 218         // resisting the drag.
 219         EXPECT_LT(shelf_size, not_visible_bounds_size + std::abs(scroll_delta));
 220       }
 221     }
 222   }
 223
 224  private:
 225   const gfx::Rect not_visible_bounds_;
 226   const gfx::Rect visible_bounds_;
 227   gfx::Vector2dF scroll_;
 228   bool was_visible_on_drag_start_;
 229
 230   DISALLOW_COPY_AND_ASSIGN(ShelfDragCallback);
 231 };
 232
 233 class ShelfLayoutObserverTest : public ShelfLayoutManagerObserver {
 234  public:
 235   ShelfLayoutObserverTest()
 236       : changed_auto_hide_state_(false) {
 237   }
 238
 239   virtual ~ShelfLayoutObserverTest() {}
 240
 241   bool changed_auto_hide_state() const { return changed_auto_hide_state_; }
 242
 243  private:
 244   virtual void OnAutoHideStateChanged(
 245       ShelfAutoHideState new_state) OVERRIDE {
 246     changed_auto_hide_state_ = true;
 247   }
 248
 249   bool changed_auto_hide_state_;
 250
 251   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutObserverTest);
 252 };
 253
 254 // Trivial item implementation that tracks its views for testing.
 255 class TestItem : public SystemTrayItem {
 256  public:
 257   TestItem()
 258       : SystemTrayItem(GetSystemTray()),
 259         tray_view_(NULL),
 260         default_view_(NULL),
 261         detailed_view_(NULL),
 262         notification_view_(NULL) {}
 263
 264   virtual views::View* CreateTrayView(user::LoginStatus status) OVERRIDE {
 265     tray_view_ = new views::View;
 266     // Add a label so it has non-zero width.
 267     tray_view_->SetLayoutManager(new views::FillLayout);
 268     tray_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Tray")));
 269     return tray_view_;
 270   }
 271
 272   virtual views::View* CreateDefaultView(user::LoginStatus status) OVERRIDE {
 273     default_view_ = new views::View;
 274     default_view_->SetLayoutManager(new views::FillLayout);
 275     default_view_->AddChildView(new views::Label(base::UTF8ToUTF16("Default")));
 276     return default_view_;
 277   }
 278
 279   virtual views::View* CreateDetailedView(user::LoginStatus status) OVERRIDE {
 280     detailed_view_ = new views::View;
 281     detailed_view_->SetLayoutManager(new views::FillLayout);
 282     detailed_view_->AddChildView(
 283         new views::Label(base::UTF8ToUTF16("Detailed")));
 284     return detailed_view_;
 285   }
 286
 287   virtual views::View* CreateNotificationView(
 288       user::LoginStatus status) OVERRIDE {
 289     notification_view_ = new views::View;
 290     return notification_view_;
 291   }
 292
 293   virtual void DestroyTrayView() OVERRIDE {
 294     tray_view_ = NULL;
 295   }
 296
 297   virtual void DestroyDefaultView() OVERRIDE {
 298     default_view_ = NULL;
 299   }
 300
 301   virtual void DestroyDetailedView() OVERRIDE {
 302     detailed_view_ = NULL;
 303   }
 304
 305   virtual void DestroyNotificationView() OVERRIDE {
 306     notification_view_ = NULL;
 307   }
 308
 309   virtual void UpdateAfterLoginStatusChange(
 310       user::LoginStatus status) OVERRIDE {}
 311
 312   views::View* tray_view() const { return tray_view_; }
 313   views::View* default_view() const { return default_view_; }
 314   views::View* detailed_view() const { return detailed_view_; }
 315   views::View* notification_view() const { return notification_view_; }
 316
 317  private:
 318   views::View* tray_view_;
 319   views::View* default_view_;
 320   views::View* detailed_view_;
 321   views::View* notification_view_;
 322
 323   DISALLOW_COPY_AND_ASSIGN(TestItem);
 324 };
 325
 326 }  // namespace
 327
 328 class ShelfLayoutManagerTest : public ash::test::AshTestBase {
 329  public:
 330   ShelfLayoutManagerTest() {}
 331
 332   void SetState(ShelfLayoutManager* shelf,
 333                 ShelfVisibilityState state) {
 334     shelf->SetState(state);
 335   }
 336
 337   void UpdateAutoHideStateNow() {
 338     GetShelfLayoutManager()->UpdateAutoHideStateNow();
 339   }
 340
 341   aura::Window* CreateTestWindow() {
 342     aura::Window* window = new aura::Window(NULL);
 343     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 344     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
 345     window->Init(aura::WINDOW_LAYER_TEXTURED);
 346     ParentWindowInPrimaryRootWindow(window);
 347     return window;
 348   }
 349
 350   views::Widget* CreateTestWidgetWithParams(
 351       const views::Widget::InitParams& params) {
 352     views::Widget* out = new views::Widget;
 353     out->Init(params);
 354     out->Show();
 355     return out;
 356   }
 357
 358   // Create a simple widget attached to the current context (will
 359   // delete on TearDown).
 360   views::Widget* CreateTestWidget() {
 361     views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 362     params.bounds = gfx::Rect(0, 0, 200, 200);
 363     params.context = CurrentContext();
 364     return CreateTestWidgetWithParams(params);
 365   }
 366
 367   // Overridden from AshTestBase:
 368   virtual void SetUp() OVERRIDE {
 369     CommandLine::ForCurrentProcess()->AppendSwitch(
 370         ash::switches::kAshEnableTrayDragging);
 371     test::AshTestBase::SetUp();
 372   }
 373
 374   void RunGestureDragTests(gfx::Vector2d);
 375
 376  private:
 377   DISALLOW_COPY_AND_ASSIGN(ShelfLayoutManagerTest);
 378 };
 379
 380 void ShelfLayoutManagerTest::RunGestureDragTests(gfx::Vector2d delta) {
 381   ShelfLayoutManager* shelf = GetShelfLayoutManager();
 382   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 383   views::Widget* widget = new views::Widget;
 384   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 385   params.bounds = gfx::Rect(0, 0, 200, 200);
 386   params.context = CurrentContext();
 387   widget->Init(params);
 388   widget->Show();
 389   widget->Maximize();
 390
 391   // The time delta should be large enough to prevent accidental fling creation.
 392   const base::TimeDelta kTimeDelta = base::TimeDelta::FromMilliseconds(100);
 393
 394   aura::Window* window = widget->GetNativeWindow();
 395   shelf->LayoutShelf();
 396
 397   gfx::Rect shelf_shown = GetShelfWidget()->GetWindowBoundsInScreen();
 398   gfx::Rect bounds_shelf = window->bounds();
 399   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 400
 401   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 402   shelf->LayoutShelf();
 403   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 404
 405   gfx::Rect bounds_noshelf = window->bounds();
 406   gfx::Rect shelf_hidden = GetShelfWidget()->GetWindowBoundsInScreen();
 407
 408   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 409   shelf->LayoutShelf();
 410
 411   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 412   const int kNumScrollSteps = 4;
 413   ShelfDragCallback handler(shelf_hidden, shelf_shown);
 414
 415   // Swipe up on the shelf. This should not change any state.
 416   gfx::Point start = GetShelfWidget()->GetWindowBoundsInScreen().CenterPoint();
 417   gfx::Point end = start + delta;
 418
 419   // Swipe down on the shelf to hide it.
 420   generator.GestureScrollSequenceWithCallback(
 421       start,
 422       end,
 423       kTimeDelta,
 424       kNumScrollSteps,
 425       base::Bind(&ShelfDragCallback::ProcessScroll,
 426                  base::Unretained(&handler)));
 427   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 428   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 429   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 430   EXPECT_NE(bounds_shelf.ToString(), window->bounds().ToString());
 431   EXPECT_NE(shelf_shown.ToString(),
 432             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 433
 434   // Swipe up to show the shelf.
 435   generator.GestureScrollSequenceWithCallback(
 436       end,
 437       start,
 438       kTimeDelta,
 439       kNumScrollSteps,
 440       base::Bind(&ShelfDragCallback::ProcessScroll,
 441                  base::Unretained(&handler)));
 442   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 443   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
 444   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
 445   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
 446             GetShelfWidget()->GetWindowBoundsInScreen());
 447   EXPECT_EQ(shelf_shown.ToString(),
 448             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 449
 450   // Swipe up again. The shelf should hide.
 451   end = start - delta;
 452   generator.GestureScrollSequenceWithCallback(
 453       start,
 454       end,
 455       kTimeDelta,
 456       kNumScrollSteps,
 457       base::Bind(&ShelfDragCallback::ProcessScroll,
 458                  base::Unretained(&handler)));
 459   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 460   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 461   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 462   EXPECT_EQ(shelf_hidden.ToString(),
 463             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 464
 465   // Swipe up yet again to show it.
 466   end = start + delta;
 467   generator.GestureScrollSequenceWithCallback(
 468       end,
 469       start,
 470       kTimeDelta,
 471       kNumScrollSteps,
 472       base::Bind(&ShelfDragCallback::ProcessScroll,
 473                  base::Unretained(&handler)));
 474
 475   // Swipe down very little. It shouldn't change any state.
 476   if (GetShelfLayoutManager()->IsHorizontalAlignment())
 477     end.set_y(start.y() + shelf_shown.height() * 3 / 10);
 478   else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
 479     end.set_x(start.x() - shelf_shown.width() * 3 / 10);
 480   else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
 481     end.set_x(start.x() + shelf_shown.width() * 3 / 10);
 482   generator.GestureScrollSequence(start, end, kTimeDelta, 5);
 483   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 484   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
 485   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
 486   EXPECT_EQ(shelf_shown.ToString(),
 487             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 488
 489   // Swipe down again to hide.
 490   end = start + delta;
 491   generator.GestureScrollSequenceWithCallback(
 492       start,
 493       end,
 494       kTimeDelta,
 495       kNumScrollSteps,
 496       base::Bind(&ShelfDragCallback::ProcessScroll,
 497                  base::Unretained(&handler)));
 498   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 499   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 500   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 501   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
 502   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
 503   EXPECT_EQ(shelf_hidden.ToString(),
 504             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 505
 506   // Swipe up in extended hit region to show it.
 507   gfx::Point extended_start = start;
 508   if (GetShelfLayoutManager()->IsHorizontalAlignment())
 509     extended_start.set_y(GetShelfWidget()->GetWindowBoundsInScreen().y() -1);
 510   else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
 511     extended_start.set_x(
 512         GetShelfWidget()->GetWindowBoundsInScreen().right() + 1);
 513   else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
 514     extended_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
 515   end = extended_start - delta;
 516   generator.GestureScrollSequenceWithCallback(
 517       extended_start,
 518       end,
 519       kTimeDelta,
 520       kNumScrollSteps,
 521       base::Bind(&ShelfDragCallback::ProcessScroll,
 522                  base::Unretained(&handler)));
 523   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 524   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
 525   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
 526   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
 527             GetShelfWidget()->GetWindowBoundsInScreen());
 528   EXPECT_EQ(shelf_shown.ToString(),
 529             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 530
 531   // Swipe down again to hide.
 532   end = start + delta;
 533   generator.GestureScrollSequenceWithCallback(
 534       start,
 535       end,
 536       kTimeDelta,
 537       kNumScrollSteps,
 538       base::Bind(&ShelfDragCallback::ProcessScroll,
 539                  base::Unretained(&handler)));
 540   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 541   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 542   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 543   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
 544   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
 545   EXPECT_EQ(shelf_hidden.ToString(),
 546             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 547
 548   // Swipe up outside the hit area. This should not change anything.
 549   gfx::Point outside_start = gfx::Point(
 550       (GetShelfWidget()->GetWindowBoundsInScreen().x() +
 551        GetShelfWidget()->GetWindowBoundsInScreen().right())/2,
 552       GetShelfWidget()->GetWindowBoundsInScreen().y() - 50);
 553   end = outside_start + delta;
 554   generator.GestureScrollSequence(
 555       outside_start, end, kTimeDelta, kNumScrollSteps);
 556   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 557   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 558   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 559   EXPECT_EQ(shelf_hidden.ToString(),
 560             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 561
 562   // Swipe up from below the shelf where a bezel would be, this should show the
 563   // shelf.
 564   gfx::Point below_start = start;
 565   if (GetShelfLayoutManager()->IsHorizontalAlignment())
 566     below_start.set_y(GetShelfWidget()->GetWindowBoundsInScreen().bottom() + 1);
 567   else if (SHELF_ALIGNMENT_LEFT == GetShelfLayoutManager()->GetAlignment())
 568     below_start.set_x(
 569         GetShelfWidget()->GetWindowBoundsInScreen().x() - 1);
 570   else if (SHELF_ALIGNMENT_RIGHT == GetShelfLayoutManager()->GetAlignment())
 571     below_start.set_x(GetShelfWidget()->GetWindowBoundsInScreen().right() + 1);
 572   end = below_start - delta;
 573   generator.GestureScrollSequence(
 574       below_start, end, kTimeDelta, kNumScrollSteps);
 575   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
 576   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
 577   EXPECT_EQ(bounds_shelf.ToString(), window->bounds().ToString());
 578   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(),
 579             GetShelfWidget()->GetWindowBoundsInScreen());
 580   EXPECT_EQ(shelf_shown.ToString(),
 581             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 582
 583   // Swipe down again to hide.
 584   end = start + delta;
 585   generator.GestureScrollSequenceWithCallback(
 586       start,
 587       end,
 588       kTimeDelta,
 589       kNumScrollSteps,
 590       base::Bind(&ShelfDragCallback::ProcessScroll,
 591                  base::Unretained(&handler)));
 592   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 593   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 594   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 595   EXPECT_EQ(GetShelfWidget()->GetDimmerBoundsForTest(), gfx::Rect());
 596   EXPECT_EQ(bounds_noshelf.ToString(), window->bounds().ToString());
 597   EXPECT_EQ(shelf_hidden.ToString(),
 598             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 599
 600   // Put |widget| into fullscreen. Set the shelf to be auto hidden when |widget|
 601   // is fullscreen. (eg browser immersive fullscreen).
 602   widget->SetFullscreen(true);
 603   wm::GetWindowState(window)->set_hide_shelf_when_fullscreen(false);
 604   shelf->UpdateVisibilityState();
 605
 606   gfx::Rect bounds_fullscreen = window->bounds();
 607   EXPECT_TRUE(widget->IsFullscreen());
 608   EXPECT_NE(bounds_noshelf.ToString(), bounds_fullscreen.ToString());
 609
 610   // Swipe up. This should show the shelf.
 611   end = below_start - delta;
 612   generator.GestureScrollSequenceWithCallback(
 613       below_start,
 614       end,
 615       kTimeDelta,
 616       kNumScrollSteps,
 617       base::Bind(&ShelfDragCallback::ProcessScroll,
 618                  base::Unretained(&handler)));
 619   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 620   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 621   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf->auto_hide_behavior());
 622   EXPECT_EQ(shelf_shown.ToString(),
 623             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 624   EXPECT_EQ(bounds_fullscreen.ToString(), window->bounds().ToString());
 625
 626   // Swipe up again. This should hide the shelf.
 627   generator.GestureScrollSequenceWithCallback(
 628       below_start,
 629       end,
 630       kTimeDelta,
 631       kNumScrollSteps,
 632       base::Bind(&ShelfDragCallback::ProcessScroll,
 633                  base::Unretained(&handler)));
 634   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 635   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 636   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 637   EXPECT_EQ(shelf_hidden.ToString(),
 638             GetShelfWidget()->GetWindowBoundsInScreen().ToString());
 639   EXPECT_EQ(bounds_fullscreen.ToString(), window->bounds().ToString());
 640
 641   // Set the shelf to be hidden when |widget| is fullscreen. (eg tab fullscreen
 642   // with or without immersive browser fullscreen).
 643   wm::GetWindowState(window)->set_hide_shelf_when_fullscreen(true);
 644   shelf->UpdateVisibilityState();
 645   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 646   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 647
 648   // Swipe-up. This should not change anything.
 649   end = start - delta;
 650   generator.GestureScrollSequenceWithCallback(
 651       below_start,
 652       end,
 653       kTimeDelta,
 654       kNumScrollSteps,
 655       base::Bind(&ShelfDragCallback::ProcessScroll,
 656                  base::Unretained(&handler)));
 657   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
 658   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 659   EXPECT_EQ(bounds_fullscreen.ToString(), window->bounds().ToString());
 660
 661   // Close actually, otherwise further event may be affected since widget
 662   // is fullscreen status.
 663   widget->Close();
 664   RunAllPendingInMessageLoop();
 665
 666   // The shelf should be shown because there are no more visible windows.
 667   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 668   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 669   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 670
 671   // Swipe-up to hide. This should have no effect because there are no visible
 672   // windows.
 673   end = below_start - delta;
 674   generator.GestureScrollSequenceWithCallback(
 675       below_start,
 676       end,
 677       kTimeDelta,
 678       kNumScrollSteps,
 679       base::Bind(&ShelfDragCallback::ProcessScroll,
 680                  base::Unretained(&handler)));
 681   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 682   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 683   EXPECT_EQ(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, shelf->auto_hide_behavior());
 684 }
 685
 686 // Need to be implemented.  http://crbug.com/111279.
 687 #if defined(OS_WIN)
 688 #define MAYBE_SetVisible DISABLED_SetVisible
 689 #else
 690 #define MAYBE_SetVisible SetVisible
 691 #endif
 692 // Makes sure SetVisible updates work area and widget appropriately.
 693 TEST_F(ShelfLayoutManagerTest, MAYBE_SetVisible) {
 694   ShelfWidget* shelf = GetShelfWidget();
 695   ShelfLayoutManager* manager = shelf->shelf_layout_manager();
 696   // Force an initial layout.
 697   manager->LayoutShelf();
 698   EXPECT_EQ(SHELF_VISIBLE, manager->visibility_state());
 699
 700   gfx::Rect status_bounds(
 701       shelf->status_area_widget()->GetWindowBoundsInScreen());
 702   gfx::Rect shelf_bounds(
 703       shelf->GetWindowBoundsInScreen());
 704   int shelf_height = manager->GetIdealBounds().height();
 705   gfx::Screen* screen = Shell::GetScreen();
 706   gfx::Display display = screen->GetDisplayNearestWindow(
 707       Shell::GetPrimaryRootWindow());
 708   ASSERT_NE(-1, display.id());
 709   // Bottom inset should be the max of widget heights.
 710   EXPECT_EQ(shelf_height, display.GetWorkAreaInsets().bottom());
 711
 712   // Hide the shelf.
 713   SetState(manager, SHELF_HIDDEN);
 714   // Run the animation to completion.
 715   StepWidgetLayerAnimatorToEnd(shelf);
 716   StepWidgetLayerAnimatorToEnd(shelf->status_area_widget());
 717   EXPECT_EQ(SHELF_HIDDEN, manager->visibility_state());
 718   display = screen->GetDisplayNearestWindow(
 719       Shell::GetPrimaryRootWindow());
 720
 721   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
 722
 723   // Make sure the bounds of the two widgets changed.
 724   EXPECT_GE(shelf->GetNativeView()->bounds().y(),
 725             screen->GetPrimaryDisplay().bounds().bottom());
 726   EXPECT_GE(shelf->status_area_widget()->GetNativeView()->bounds().y(),
 727             screen->GetPrimaryDisplay().bounds().bottom());
 728
 729   // And show it again.
 730   SetState(manager, SHELF_VISIBLE);
 731   // Run the animation to completion.
 732   StepWidgetLayerAnimatorToEnd(shelf);
 733   StepWidgetLayerAnimatorToEnd(shelf->status_area_widget());
 734   EXPECT_EQ(SHELF_VISIBLE, manager->visibility_state());
 735   display = screen->GetDisplayNearestWindow(
 736       Shell::GetPrimaryRootWindow());
 737   EXPECT_EQ(shelf_height, display.GetWorkAreaInsets().bottom());
 738
 739   // Make sure the bounds of the two widgets changed.
 740   shelf_bounds = shelf->GetNativeView()->bounds();
 741   EXPECT_LT(shelf_bounds.y(), screen->GetPrimaryDisplay().bounds().bottom());
 742   status_bounds = shelf->status_area_widget()->GetNativeView()->bounds();
 743   EXPECT_LT(status_bounds.y(),
 744             screen->GetPrimaryDisplay().bounds().bottom());
 745 }
 746
 747 // Makes sure shelf alignment is correct for lock screen.
 748 TEST_F(ShelfLayoutManagerTest, SideAlignmentInteractionWithLockScreen) {
 749   ShelfLayoutManager* manager = GetShelfWidget()->shelf_layout_manager();
 750   manager->SetAlignment(SHELF_ALIGNMENT_LEFT);
 751   EXPECT_EQ(SHELF_ALIGNMENT_LEFT, manager->GetAlignment());
 752   Shell::GetInstance()->session_state_delegate()->LockScreen();
 753   EXPECT_EQ(SHELF_ALIGNMENT_BOTTOM, manager->GetAlignment());
 754   Shell::GetInstance()->session_state_delegate()->UnlockScreen();
 755   EXPECT_EQ(SHELF_ALIGNMENT_LEFT, manager->GetAlignment());
 756 }
 757
 758 // Makes sure LayoutShelf invoked while animating cleans things up.
 759 TEST_F(ShelfLayoutManagerTest, LayoutShelfWhileAnimating) {
 760   ShelfWidget* shelf = GetShelfWidget();
 761   // Force an initial layout.
 762   shelf->shelf_layout_manager()->LayoutShelf();
 763   EXPECT_EQ(SHELF_VISIBLE, shelf->shelf_layout_manager()->visibility_state());
 764
 765   // Hide the shelf.
 766   SetState(shelf->shelf_layout_manager(), SHELF_HIDDEN);
 767   shelf->shelf_layout_manager()->LayoutShelf();
 768   EXPECT_EQ(SHELF_HIDDEN, shelf->shelf_layout_manager()->visibility_state());
 769   gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
 770       Shell::GetPrimaryRootWindow());
 771   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
 772
 773   // Make sure the bounds of the two widgets changed.
 774   EXPECT_GE(shelf->GetNativeView()->bounds().y(),
 775             Shell::GetScreen()->GetPrimaryDisplay().bounds().bottom());
 776   EXPECT_GE(shelf->status_area_widget()->GetNativeView()->bounds().y(),
 777             Shell::GetScreen()->GetPrimaryDisplay().bounds().bottom());
 778 }
 779
 780 // Test that switching to a different visibility state does not restart the
 781 // shelf show / hide animation if it is already running. (crbug.com/250918)
 782 TEST_F(ShelfLayoutManagerTest, SetStateWhileAnimating) {
 783   ShelfWidget* shelf = GetShelfWidget();
 784   SetState(shelf->shelf_layout_manager(), SHELF_VISIBLE);
 785   gfx::Rect initial_shelf_bounds = shelf->GetWindowBoundsInScreen();
 786   gfx::Rect initial_status_bounds =
 787       shelf->status_area_widget()->GetWindowBoundsInScreen();
 788
 789   ui::ScopedAnimationDurationScaleMode normal_animation_duration(
 790       ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
 791   SetState(shelf->shelf_layout_manager(), SHELF_HIDDEN);
 792   SetState(shelf->shelf_layout_manager(), SHELF_VISIBLE);
 793
 794   gfx::Rect current_shelf_bounds = shelf->GetWindowBoundsInScreen();
 795   gfx::Rect current_status_bounds =
 796       shelf->status_area_widget()->GetWindowBoundsInScreen();
 797
 798   const int small_change = initial_shelf_bounds.height() / 2;
 799   EXPECT_LE(
 800       std::abs(initial_shelf_bounds.height() - current_shelf_bounds.height()),
 801       small_change);
 802   EXPECT_LE(
 803       std::abs(initial_status_bounds.height() - current_status_bounds.height()),
 804       small_change);
 805 }
 806
 807 // Makes sure the shelf is sized when the status area changes size.
 808 TEST_F(ShelfLayoutManagerTest, ShelfUpdatedWhenStatusAreaChangesSize) {
 809   Shelf* shelf = Shelf::ForPrimaryDisplay();
 810   ASSERT_TRUE(shelf);
 811   ShelfWidget* shelf_widget = GetShelfWidget();
 812   ASSERT_TRUE(shelf_widget);
 813   ASSERT_TRUE(shelf_widget->status_area_widget());
 814   shelf_widget->status_area_widget()->SetBounds(
 815       gfx::Rect(0, 0, 200, 200));
 816   EXPECT_EQ(200, shelf_widget->GetContentsView()->width() -
 817             test::ShelfTestAPI(shelf).shelf_view()->width());
 818 }
 819
 820
 821 #if defined(OS_WIN)
 822 // RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
 823 #define MAYBE_AutoHide DISABLED_AutoHide
 824 #else
 825 #define MAYBE_AutoHide AutoHide
 826 #endif
 827
 828 // Various assertions around auto-hide.
 829 TEST_F(ShelfLayoutManagerTest, MAYBE_AutoHide) {
 830   aura::Window* root = Shell::GetPrimaryRootWindow();
 831   ui::test::EventGenerator generator(root, root);
 832   generator.MoveMouseTo(0, 0);
 833
 834   ShelfLayoutManager* shelf = GetShelfLayoutManager();
 835   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 836   views::Widget* widget = new views::Widget;
 837   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 838   params.bounds = gfx::Rect(0, 0, 200, 200);
 839   params.context = CurrentContext();
 840   // Widget is now owned by the parent window.
 841   widget->Init(params);
 842   widget->Maximize();
 843   widget->Show();
 844   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 845   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 846
 847   // LayoutShelf() forces the animation to completion, at which point the
 848   // shelf should go off the screen.
 849   shelf->LayoutShelf();
 850   EXPECT_EQ(root->bounds().bottom() - ShelfLayoutManager::kAutoHideSize,
 851             GetShelfWidget()->GetWindowBoundsInScreen().y());
 852   EXPECT_EQ(root->bounds().bottom() - ShelfLayoutManager::kAutoHideSize,
 853             Shell::GetScreen()->GetDisplayNearestWindow(
 854                 root).work_area().bottom());
 855
 856   // Move the mouse to the bottom of the screen.
 857   generator.MoveMouseTo(0, root->bounds().bottom() - 1);
 858
 859   // Shelf should be shown again (but it shouldn't have changed the work area).
 860   SetState(shelf, SHELF_AUTO_HIDE);
 861   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 862   shelf->LayoutShelf();
 863   EXPECT_EQ(root->bounds().bottom() - shelf->GetIdealBounds().height(),
 864             GetShelfWidget()->GetWindowBoundsInScreen().y());
 865   EXPECT_EQ(root->bounds().bottom() - ShelfLayoutManager::kAutoHideSize,
 866             Shell::GetScreen()->GetDisplayNearestWindow(
 867                 root).work_area().bottom());
 868
 869   // Move mouse back up.
 870   generator.MoveMouseTo(0, 0);
 871   SetState(shelf, SHELF_AUTO_HIDE);
 872   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 873   shelf->LayoutShelf();
 874   EXPECT_EQ(root->bounds().bottom() - ShelfLayoutManager::kAutoHideSize,
 875             GetShelfWidget()->GetWindowBoundsInScreen().y());
 876
 877   // Drag mouse to bottom of screen.
 878   generator.PressLeftButton();
 879   generator.MoveMouseTo(0, root->bounds().bottom() - 1);
 880   UpdateAutoHideStateNow();
 881   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 882
 883   generator.ReleaseLeftButton();
 884   generator.MoveMouseTo(1, root->bounds().bottom() - 1);
 885   UpdateAutoHideStateNow();
 886   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 887   generator.PressLeftButton();
 888   generator.MoveMouseTo(1, root->bounds().bottom() - 1);
 889   UpdateAutoHideStateNow();
 890   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 891 }
 892
 893 // Test the behavior of the shelf when it is auto hidden and it is on the
 894 // boundary between the primary and the secondary display.
 895 TEST_F(ShelfLayoutManagerTest, AutoHideShelfOnScreenBoundary) {
 896   if (!SupportsMultipleDisplays())
 897     return;
 898
 899   UpdateDisplay("800x600,800x600");
 900   DisplayLayout display_layout(DisplayLayout::RIGHT, 0);
 901   Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
 902       display_layout);
 903   // Put the primary monitor's shelf on the display boundary.
 904   ShelfLayoutManager* shelf = GetShelfLayoutManager();
 905   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
 906
 907   // Create a window because the shelf is always shown when no windows are
 908   // visible.
 909   CreateTestWidget();
 910
 911   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 912   ASSERT_EQ(root_windows[0],
 913             GetShelfWidget()->GetNativeWindow()->GetRootWindow());
 914
 915   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 916   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 917
 918   int right_edge = root_windows[0]->GetBoundsInScreen().right() - 1;
 919   int y = root_windows[0]->GetBoundsInScreen().y();
 920
 921   // Start off the mouse nowhere near the shelf; the shelf should be hidden.
 922   ui::test::EventGenerator& generator(GetEventGenerator());
 923   generator.MoveMouseTo(right_edge - 50, y);
 924   UpdateAutoHideStateNow();
 925   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 926
 927   // Moving the mouse over the light bar (but not to the edge of the screen)
 928   // should show the shelf.
 929   generator.MoveMouseTo(right_edge - 1, y);
 930   UpdateAutoHideStateNow();
 931   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 932   EXPECT_EQ(right_edge - 1, Shell::GetScreen()->GetCursorScreenPoint().x());
 933
 934   // Moving the mouse off the light bar should hide the shelf.
 935   generator.MoveMouseTo(right_edge - 50, y);
 936   UpdateAutoHideStateNow();
 937   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 938
 939   // Moving the mouse to the right edge of the screen crossing the light bar
 940   // should show the shelf despite the mouse cursor getting warped to the
 941   // secondary display.
 942   generator.MoveMouseTo(right_edge - 1, y);
 943   generator.MoveMouseTo(right_edge, y);
 944   UpdateAutoHideStateNow();
 945   EXPECT_NE(right_edge - 1, Shell::GetScreen()->GetCursorScreenPoint().x());
 946   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 947
 948   // Hide the shelf.
 949   generator.MoveMouseTo(right_edge - 50, y);
 950   UpdateAutoHideStateNow();
 951   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 952
 953   // Moving the mouse to the right edge of the screen crossing the light bar and
 954   // overshooting by a lot should keep the shelf hidden.
 955   generator.MoveMouseTo(right_edge - 1, y);
 956   generator.MoveMouseTo(right_edge + 50, y);
 957   UpdateAutoHideStateNow();
 958   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 959
 960   // Moving the mouse to the right edge of the screen crossing the light bar and
 961   // overshooting a bit should show the shelf.
 962   generator.MoveMouseTo(right_edge - 1, y);
 963   generator.MoveMouseTo(right_edge + 2, y);
 964   UpdateAutoHideStateNow();
 965   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 966
 967   // Keeping the mouse close to the left edge of the secondary display after the
 968   // shelf is shown should keep the shelf shown.
 969   generator.MoveMouseTo(right_edge + 2, y + 1);
 970   UpdateAutoHideStateNow();
 971   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
 972
 973   // Moving the mouse far from the left edge of the secondary display should
 974   // hide the shelf.
 975   generator.MoveMouseTo(right_edge + 50, y);
 976   UpdateAutoHideStateNow();
 977   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 978
 979   // Moving to the left edge of the secondary display without first crossing
 980   // the primary display's right aligned shelf first should not show the shelf.
 981   generator.MoveMouseTo(right_edge + 2, y);
 982   UpdateAutoHideStateNow();
 983   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 984 }
 985
 986 // Assertions around the lock screen showing.
 987 TEST_F(ShelfLayoutManagerTest, VisibleWhenLockScreenShowing) {
 988   // Since ShelfLayoutManager queries for mouse location, move the mouse so
 989   // it isn't over the shelf.
 990   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 991                                      gfx::Point());
 992   generator.MoveMouseTo(0, 0);
 993
 994   ShelfLayoutManager* shelf = GetShelfLayoutManager();
 995   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 996   views::Widget* widget = new views::Widget;
 997   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
 998   params.bounds = gfx::Rect(0, 0, 200, 200);
 999   params.context = CurrentContext();
1000   // Widget is now owned by the parent window.
1001   widget->Init(params);
1002   widget->Maximize();
1003   widget->Show();
1004   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1005   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1006
1007   aura::Window* root = Shell::GetPrimaryRootWindow();
1008   // LayoutShelf() forces the animation to completion, at which point the
1009   // shelf should go off the screen.
1010   shelf->LayoutShelf();
1011   EXPECT_EQ(root->bounds().bottom() - ShelfLayoutManager::kAutoHideSize,
1012             GetShelfWidget()->GetWindowBoundsInScreen().y());
1013
1014   aura::Window* lock_container = Shell::GetContainer(
1015       Shell::GetPrimaryRootWindow(), kShellWindowId_LockScreenContainer);
1016
1017   views::Widget* lock_widget = new views::Widget;
1018   views::Widget::InitParams lock_params(
1019       views::Widget::InitParams::TYPE_WINDOW);
1020   lock_params.bounds = gfx::Rect(0, 0, 200, 200);
1021   params.context = CurrentContext();
1022   lock_params.parent = lock_container;
1023   // Widget is now owned by the parent window.
1024   lock_widget->Init(lock_params);
1025   lock_widget->Maximize();
1026   lock_widget->Show();
1027
1028   // Lock the screen.
1029   Shell::GetInstance()->session_state_delegate()->LockScreen();
1030   shelf->UpdateVisibilityState();
1031   // Showing a widget in the lock screen should force the shelf to be visibile.
1032   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1033
1034   Shell::GetInstance()->session_state_delegate()->UnlockScreen();
1035   shelf->UpdateVisibilityState();
1036   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1037 }
1038
1039 // Assertions around SetAutoHideBehavior.
1040 TEST_F(ShelfLayoutManagerTest, SetAutoHideBehavior) {
1041   // Since ShelfLayoutManager queries for mouse location, move the mouse so
1042   // it isn't over the shelf.
1043   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
1044                                      gfx::Point());
1045   generator.MoveMouseTo(0, 0);
1046
1047   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1048   views::Widget* widget = new views::Widget;
1049   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1050   params.bounds = gfx::Rect(0, 0, 200, 200);
1051   params.context = CurrentContext();
1052   // Widget is now owned by the parent window.
1053   widget->Init(params);
1054   widget->Show();
1055   aura::Window* window = widget->GetNativeWindow();
1056   gfx::Rect display_bounds(
1057       Shell::GetScreen()->GetDisplayNearestWindow(window).bounds());
1058
1059   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1060   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1061
1062   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1063   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1064
1065   widget->Maximize();
1066   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1067   EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
1068                 window).work_area().bottom(),
1069             widget->GetWorkAreaBoundsInScreen().bottom());
1070
1071   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1072   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1073   EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
1074                 window).work_area().bottom(),
1075             widget->GetWorkAreaBoundsInScreen().bottom());
1076
1077   ui::ScopedAnimationDurationScaleMode animation_duration(
1078       ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
1079
1080   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1081   ShelfWidget* shelf_widget = GetShelfWidget();
1082   EXPECT_TRUE(shelf_widget->status_area_widget()->IsVisible());
1083   StepWidgetLayerAnimatorToEnd(shelf_widget);
1084   StepWidgetLayerAnimatorToEnd(shelf_widget->status_area_widget());
1085   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1086   EXPECT_EQ(Shell::GetScreen()->GetDisplayNearestWindow(
1087                 window).work_area().bottom(),
1088             widget->GetWorkAreaBoundsInScreen().bottom());
1089 }
1090
1091 // Basic assertions around the dimming of the shelf.
1092 TEST_F(ShelfLayoutManagerTest, TestDimmingBehavior) {
1093   // Since ShelfLayoutManager queries for mouse location, move the mouse so
1094   // it isn't over the shelf.
1095   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
1096                                      gfx::Point());
1097   generator.MoveMouseTo(0, 0);
1098
1099   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1100   shelf->shelf_widget()->DisableDimmingAnimationsForTest();
1101
1102   views::Widget* widget = new views::Widget;
1103   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1104   params.bounds = gfx::Rect(0, 0, 200, 200);
1105   params.context = CurrentContext();
1106   // Widget is now owned by the parent window.
1107   widget->Init(params);
1108   widget->Show();
1109   aura::Window* window = widget->GetNativeWindow();
1110   gfx::Rect display_bounds(
1111       Shell::GetScreen()->GetDisplayNearestWindow(window).bounds());
1112
1113   gfx::Point off_shelf = display_bounds.CenterPoint();
1114   gfx::Point on_shelf =
1115       shelf->shelf_widget()->GetWindowBoundsInScreen().CenterPoint();
1116
1117   // Test there is no dimming object active at this point.
1118   generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
1119   EXPECT_EQ(-1, shelf->shelf_widget()->GetDimmingAlphaForTest());
1120   generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
1121   EXPECT_EQ(-1, shelf->shelf_widget()->GetDimmingAlphaForTest());
1122
1123   // After maximization, the shelf should be visible and the dimmer created.
1124   widget->Maximize();
1125
1126   on_shelf = shelf->shelf_widget()->GetWindowBoundsInScreen().CenterPoint();
1127   EXPECT_LT(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1128
1129   // Moving the mouse off the shelf should dim the bar.
1130   generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
1131   EXPECT_LT(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1132
1133   // Adding touch events outside the shelf should still keep the shelf in
1134   // dimmed state.
1135   generator.PressTouch();
1136   generator.MoveTouch(off_shelf);
1137   EXPECT_LT(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1138   // Move the touch into the shelf area should undim.
1139   generator.MoveTouch(on_shelf);
1140   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1141   generator.ReleaseTouch();
1142   // And a release dims again.
1143   EXPECT_LT(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1144
1145   // Moving the mouse on the shelf should undim the bar.
1146   generator.MoveMouseTo(on_shelf);
1147   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1148
1149   // No matter what the touch events do, the shelf should stay undimmed.
1150   generator.PressTouch();
1151   generator.MoveTouch(off_shelf);
1152   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1153   generator.MoveTouch(on_shelf);
1154   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1155   generator.MoveTouch(off_shelf);
1156   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1157   generator.MoveTouch(on_shelf);
1158   generator.ReleaseTouch();
1159
1160   // After restore, the dimming object should be deleted again.
1161   widget->Restore();
1162   EXPECT_EQ(-1, shelf->shelf_widget()->GetDimmingAlphaForTest());
1163 }
1164
1165 // Assertions around the dimming of the shelf in conjunction with menus.
1166 TEST_F(ShelfLayoutManagerTest, TestDimmingBehaviorWithMenus) {
1167   // Since ShelfLayoutManager queries for mouse location, move the mouse so
1168   // it isn't over the shelf.
1169   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
1170                                      gfx::Point());
1171   generator.MoveMouseTo(0, 0);
1172
1173   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1174   shelf->shelf_widget()->DisableDimmingAnimationsForTest();
1175
1176   views::Widget* widget = new views::Widget;
1177   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1178   params.bounds = gfx::Rect(0, 0, 200, 200);
1179   params.context = CurrentContext();
1180   // Widget is now owned by the parent window.
1181   widget->Init(params);
1182   widget->Show();
1183   aura::Window* window = widget->GetNativeWindow();
1184   gfx::Rect display_bounds(
1185       Shell::GetScreen()->GetDisplayNearestWindow(window).bounds());
1186
1187   // After maximization, the shelf should be visible and the dimmer created.
1188   widget->Maximize();
1189
1190   gfx::Point off_shelf = display_bounds.CenterPoint();
1191   gfx::Point on_shelf =
1192       shelf->shelf_widget()->GetWindowBoundsInScreen().CenterPoint();
1193
1194   // Moving the mouse on the shelf should undim the bar.
1195   generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
1196   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1197
1198   // Simulate a menu opening.
1199   shelf->shelf_widget()->ForceUndimming(true);
1200
1201   // Moving the mouse off the shelf should not dim the bar.
1202   generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
1203   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1204
1205   // No matter what the touch events do, the shelf should stay undimmed.
1206   generator.PressTouch();
1207   generator.MoveTouch(off_shelf);
1208   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1209   generator.MoveTouch(on_shelf);
1210   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1211   generator.MoveTouch(off_shelf);
1212   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1213   generator.ReleaseTouch();
1214   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1215
1216   // "Closing the menu" should now turn off the menu since no event is inside
1217   // the shelf any longer.
1218   shelf->shelf_widget()->ForceUndimming(false);
1219   EXPECT_LT(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1220
1221   // Moving the mouse again on the shelf which should undim the bar again.
1222   // This time we check that the bar stays undimmed when the mouse remains on
1223   // the bar and the "menu gets closed".
1224   generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
1225   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1226   shelf->shelf_widget()->ForceUndimming(true);
1227   generator.MoveMouseTo(off_shelf.x(), off_shelf.y());
1228   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1229   generator.MoveMouseTo(on_shelf.x(), on_shelf.y());
1230   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1231   shelf->shelf_widget()->ForceUndimming(true);
1232   EXPECT_EQ(0, shelf->shelf_widget()->GetDimmingAlphaForTest());
1233 }
1234
1235 // Verifies the shelf is visible when status/shelf is focused.
1236 TEST_F(ShelfLayoutManagerTest, VisibleWhenStatusOrShelfFocused) {
1237   // Since ShelfLayoutManager queries for mouse location, move the mouse so
1238   // it isn't over the shelf.
1239   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
1240                                      gfx::Point());
1241   generator.MoveMouseTo(0, 0);
1242
1243   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1244   views::Widget* widget = new views::Widget;
1245   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1246   params.bounds = gfx::Rect(0, 0, 200, 200);
1247   params.context = CurrentContext();
1248   // Widget is now owned by the parent window.
1249   widget->Init(params);
1250   widget->Show();
1251   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1252   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1253   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1254
1255   // Focus the shelf. Have to go through the focus cycler as normal focus
1256   // requests to it do nothing.
1257   GetShelfWidget()->GetFocusCycler()->RotateFocus(FocusCycler::FORWARD);
1258   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1259
1260   widget->Activate();
1261   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1262
1263   // Trying to activate the status should fail, since we only allow activating
1264   // it when the user is using the keyboard (i.e. through FocusCycler).
1265   GetShelfWidget()->status_area_widget()->Activate();
1266   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1267
1268   GetShelfWidget()->GetFocusCycler()->RotateFocus(FocusCycler::FORWARD);
1269   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1270 }
1271
1272 // Makes sure shelf will be visible when app list opens as shelf is in
1273 // SHELF_VISIBLE state,and toggling app list won't change shelf
1274 // visibility state.
1275 TEST_F(ShelfLayoutManagerTest, OpenAppListWithShelfVisibleState) {
1276   Shell* shell = Shell::GetInstance();
1277   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1278   shelf->LayoutShelf();
1279   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1280
1281   // Create a normal unmaximized windowm shelf should be visible.
1282   aura::Window* window = CreateTestWindow();
1283   window->SetBounds(gfx::Rect(0, 0, 100, 100));
1284   window->Show();
1285   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1286   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1287
1288   // Show app list and the shelf stays visible.
1289   shell->ShowAppList(NULL);
1290   EXPECT_TRUE(shell->GetAppListTargetVisibility());
1291   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1292
1293   // Hide app list and the shelf stays visible.
1294   shell->DismissAppList();
1295   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1296   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1297 }
1298
1299 // Makes sure shelf will be shown with SHELF_AUTO_HIDE_SHOWN state
1300 // when app list opens as shelf is in SHELF_AUTO_HIDE state, and
1301 // toggling app list won't change shelf visibility state.
1302 TEST_F(ShelfLayoutManagerTest, OpenAppListWithShelfAutoHideState) {
1303   Shell* shell = Shell::GetInstance();
1304   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1305   shelf->LayoutShelf();
1306   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1307
1308   // Create a window and show it in maximized state.
1309   aura::Window* window = CreateTestWindow();
1310   window->SetBounds(gfx::Rect(0, 0, 100, 100));
1311   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1312   window->Show();
1313   wm::ActivateWindow(window);
1314
1315   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1316   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1317
1318   // Show app list.
1319   shell->ShowAppList(NULL);
1320   // The shelf's auto hide state won't be changed until the timer fires, so
1321   // calling shell->UpdateShelfVisibility() is kind of manually helping it to
1322   // update the state.
1323   shell->UpdateShelfVisibility();
1324   EXPECT_TRUE(shell->GetAppListTargetVisibility());
1325   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1326   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1327
1328   // Hide app list.
1329   shell->DismissAppList();
1330   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1331   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1332 }
1333
1334 // Makes sure shelf will be hidden when app list opens as shelf is in HIDDEN
1335 // state, and toggling app list won't change shelf visibility state.
1336 TEST_F(ShelfLayoutManagerTest, OpenAppListWithShelfHiddenState) {
1337   Shell* shell = Shell::GetInstance();
1338   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1339   // For shelf to be visible, app list is not open in initial state.
1340   shelf->LayoutShelf();
1341
1342   // Create a window and make it full screen.
1343   aura::Window* window = CreateTestWindow();
1344   window->SetBounds(gfx::Rect(0, 0, 100, 100));
1345   window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
1346   window->Show();
1347   wm::ActivateWindow(window);
1348
1349   // App list and shelf is not shown.
1350   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1351   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
1352
1353   // Show app list.
1354   shell->ShowAppList(NULL);
1355   EXPECT_TRUE(shell->GetAppListTargetVisibility());
1356   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
1357
1358   // Hide app list.
1359   shell->DismissAppList();
1360   EXPECT_FALSE(shell->GetAppListTargetVisibility());
1361   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
1362 }
1363
1364 // Tests that the shelf is only hidden for a fullscreen window at the front and
1365 // toggles visibility when another window is activated.
1366 TEST_F(ShelfLayoutManagerTest, FullscreenWindowInFrontHidesShelf) {
1367   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1368
1369   // Create a window and make it full screen.
1370   aura::Window* window1 = CreateTestWindow();
1371   window1->SetBounds(gfx::Rect(0, 0, 100, 100));
1372   window1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
1373   window1->Show();
1374
1375   aura::Window* window2 = CreateTestWindow();
1376   window2->SetBounds(gfx::Rect(0, 0, 100, 100));
1377   window2->Show();
1378
1379   wm::GetWindowState(window1)->Activate();
1380   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
1381
1382   wm::GetWindowState(window2)->Activate();
1383   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1384
1385   wm::GetWindowState(window1)->Activate();
1386   EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state());
1387 }
1388
1389 // Test the behavior of the shelf when a window on one display is fullscreen
1390 // but the other display has the active window.
1391 TEST_F(ShelfLayoutManagerTest, FullscreenWindowOnSecondDisplay) {
1392   if (!SupportsMultipleDisplays())
1393     return;
1394
1395   UpdateDisplay("800x600,800x600");
1396   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
1397   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
1398   Shell::RootWindowControllerList root_window_controllers =
1399       Shell::GetAllRootWindowControllers();
1400
1401   // Create windows on either display.
1402   aura::Window* window1 = CreateTestWindow();
1403   window1->SetBoundsInScreen(
1404       gfx::Rect(0, 0, 100, 100),
1405       display_manager->GetDisplayAt(0));
1406   window1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
1407   window1->Show();
1408
1409   aura::Window* window2 = CreateTestWindow();
1410   window2->SetBoundsInScreen(
1411       gfx::Rect(800, 0, 100, 100),
1412       display_manager->GetDisplayAt(1));
1413   window2->Show();
1414
1415   EXPECT_EQ(root_windows[0], window1->GetRootWindow());
1416   EXPECT_EQ(root_windows[1], window2->GetRootWindow());
1417
1418   wm::GetWindowState(window2)->Activate();
1419   EXPECT_EQ(SHELF_HIDDEN,
1420       root_window_controllers[0]->GetShelfLayoutManager()->visibility_state());
1421   EXPECT_EQ(SHELF_VISIBLE,
1422       root_window_controllers[1]->GetShelfLayoutManager()->visibility_state());
1423 }
1424
1425
1426 #if defined(OS_WIN)
1427 // RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
1428 #define MAYBE_SetAlignment DISABLED_SetAlignment
1429 #else
1430 #define MAYBE_SetAlignment SetAlignment
1431 #endif
1432
1433 // Tests SHELF_ALIGNMENT_(LEFT, RIGHT, TOP).
1434 TEST_F(ShelfLayoutManagerTest, MAYBE_SetAlignment) {
1435   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1436   // Force an initial layout.
1437   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1438   shelf->LayoutShelf();
1439   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1440
1441   shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
1442   gfx::Rect shelf_bounds(
1443       GetShelfWidget()->GetWindowBoundsInScreen());
1444   const gfx::Screen* screen = Shell::GetScreen();
1445   gfx::Display display =
1446       screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1447   ASSERT_NE(-1, display.id());
1448   EXPECT_EQ(shelf->GetIdealBounds().width(),
1449             display.GetWorkAreaInsets().left());
1450   EXPECT_GE(
1451       shelf_bounds.width(),
1452       GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
1453   EXPECT_EQ(SHELF_ALIGNMENT_LEFT, GetSystemTray()->shelf_alignment());
1454   StatusAreaWidget* status_area_widget = GetShelfWidget()->status_area_widget();
1455   gfx::Rect status_bounds(status_area_widget->GetWindowBoundsInScreen());
1456   EXPECT_GE(status_bounds.width(),
1457             status_area_widget->GetContentsView()->GetPreferredSize().width());
1458   EXPECT_EQ(shelf->GetIdealBounds().width(),
1459             display.GetWorkAreaInsets().left());
1460   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
1461   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
1462   EXPECT_EQ(0, display.GetWorkAreaInsets().right());
1463   EXPECT_EQ(display.bounds().x(), shelf_bounds.x());
1464   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
1465   EXPECT_EQ(display.bounds().height(), shelf_bounds.height());
1466   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1467   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1468   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
1469       display.GetWorkAreaInsets().left());
1470   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize, display.work_area().x());
1471
1472   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1473   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
1474   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1475   shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
1476   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1477   ASSERT_NE(-1, display.id());
1478   EXPECT_EQ(shelf->GetIdealBounds().width(),
1479             display.GetWorkAreaInsets().right());
1480   EXPECT_GE(shelf_bounds.width(),
1481             GetShelfWidget()->GetContentsView()->GetPreferredSize().width());
1482   EXPECT_EQ(SHELF_ALIGNMENT_RIGHT, GetSystemTray()->shelf_alignment());
1483   status_bounds = gfx::Rect(status_area_widget->GetWindowBoundsInScreen());
1484   EXPECT_GE(status_bounds.width(),
1485             status_area_widget->GetContentsView()->GetPreferredSize().width());
1486   EXPECT_EQ(shelf->GetIdealBounds().width(),
1487             display.GetWorkAreaInsets().right());
1488   EXPECT_EQ(0, display.GetWorkAreaInsets().top());
1489   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
1490   EXPECT_EQ(0, display.GetWorkAreaInsets().left());
1491   EXPECT_EQ(display.work_area().right(), shelf_bounds.x());
1492   EXPECT_EQ(display.bounds().y(), shelf_bounds.y());
1493   EXPECT_EQ(display.bounds().height(), shelf_bounds.height());
1494   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1495   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1496   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
1497       display.GetWorkAreaInsets().right());
1498   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
1499       display.bounds().right() - display.work_area().right());
1500
1501   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1502   shelf->SetAlignment(SHELF_ALIGNMENT_TOP);
1503   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1504   shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
1505   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1506   ASSERT_NE(-1, display.id());
1507   EXPECT_EQ(shelf->GetIdealBounds().height(),
1508             display.GetWorkAreaInsets().top());
1509   EXPECT_GE(shelf_bounds.height(),
1510             GetShelfWidget()->GetContentsView()->GetPreferredSize().height());
1511   EXPECT_EQ(SHELF_ALIGNMENT_TOP, GetSystemTray()->shelf_alignment());
1512   status_bounds = gfx::Rect(status_area_widget->GetWindowBoundsInScreen());
1513   EXPECT_GE(status_bounds.height(),
1514             status_area_widget->GetContentsView()->GetPreferredSize().height());
1515   EXPECT_EQ(shelf->GetIdealBounds().height(),
1516             display.GetWorkAreaInsets().top());
1517   EXPECT_EQ(0, display.GetWorkAreaInsets().right());
1518   EXPECT_EQ(0, display.GetWorkAreaInsets().bottom());
1519   EXPECT_EQ(0, display.GetWorkAreaInsets().left());
1520   EXPECT_EQ(display.work_area().y(), shelf_bounds.bottom());
1521   EXPECT_EQ(display.bounds().x(), shelf_bounds.x());
1522   EXPECT_EQ(display.bounds().width(), shelf_bounds.width());
1523   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1524   display = screen->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow());
1525   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
1526       display.GetWorkAreaInsets().top());
1527   EXPECT_EQ(ShelfLayoutManager::kAutoHideSize,
1528             display.work_area().y() - display.bounds().y());
1529 }
1530
1531 TEST_F(ShelfLayoutManagerTest, GestureEdgeSwipe) {
1532   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1533   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1534   views::Widget* widget = new views::Widget;
1535   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1536   params.bounds = gfx::Rect(0, 0, 200, 200);
1537   params.context = CurrentContext();
1538   widget->Init(params);
1539   widget->Show();
1540   widget->Maximize();
1541
1542   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1543
1544   aura::Window* window = widget->GetNativeWindow();
1545   shelf->LayoutShelf();
1546
1547   gfx::Rect shelf_shown = GetShelfWidget()->GetWindowBoundsInScreen();
1548   gfx::Rect bounds_shelf = window->bounds();
1549
1550   // Edge swipe when SHELF_VISIBLE should not change visibility state.
1551   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1552   generator.GestureEdgeSwipe();
1553   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1554
1555   // Edge swipe when AUTO_HIDE_HIDDEN should change to AUTO_HIDE_SHOWN.
1556   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1557   shelf->LayoutShelf();
1558   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1559   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1560   generator.GestureEdgeSwipe();
1561   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1562   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1563
1564   widget->SetFullscreen(true);
1565   wm::GetWindowState(window)->set_hide_shelf_when_fullscreen(false);
1566   shelf->UpdateVisibilityState();
1567
1568   // Edge swipe in fullscreen + AUTO_HIDE_HIDDEN should show the shelf and
1569   // remain fullscreen.
1570   EXPECT_TRUE(widget->IsFullscreen());
1571   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1572   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1573   generator.GestureEdgeSwipe();
1574   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1575   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1576   EXPECT_TRUE(widget->IsFullscreen());
1577 }
1578
1579 #if defined(OS_WIN)
1580 // RootWindow and Display can't resize on Windows Ash. http://crbug.com/165962
1581 #define MAYBE_GestureDrag DISABLED_GestureDrag
1582 #else
1583 #define MAYBE_GestureDrag GestureDrag
1584 #endif
1585
1586 TEST_F(ShelfLayoutManagerTest, MAYBE_GestureDrag) {
1587   // Slop is an implementation detail of gesture recognition, and complicates
1588   // these tests. Ignore it.
1589   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(0);
1590   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1591   {
1592     SCOPED_TRACE("BOTTOM");
1593     RunGestureDragTests(gfx::Vector2d(0, 120));
1594   }
1595
1596   {
1597     SCOPED_TRACE("LEFT");
1598     shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
1599     RunGestureDragTests(gfx::Vector2d(-120, 0));
1600   }
1601
1602   {
1603     SCOPED_TRACE("RIGHT");
1604     shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
1605     RunGestureDragTests(gfx::Vector2d(120, 0));
1606   }
1607 }
1608
1609 TEST_F(ShelfLayoutManagerTest, WindowVisibilityDisablesAutoHide) {
1610   if (!SupportsMultipleDisplays())
1611     return;
1612
1613   UpdateDisplay("800x600,800x600");
1614   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1615   shelf->LayoutShelf();
1616   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1617
1618   // Create a visible window so auto-hide behavior is enforced
1619   views::Widget* dummy = CreateTestWidget();
1620
1621   // Window visible => auto hide behaves normally.
1622   shelf->UpdateVisibilityState();
1623   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1624
1625   // Window minimized => auto hide disabled.
1626   dummy->Minimize();
1627   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1628
1629   // Window closed => auto hide disabled.
1630   dummy->CloseNow();
1631   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1632
1633   // Multiple window test
1634   views::Widget* window1 = CreateTestWidget();
1635   views::Widget* window2 = CreateTestWidget();
1636
1637   // both visible => normal autohide
1638   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1639
1640   // either minimzed => normal autohide
1641   window2->Minimize();
1642   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1643   window2->Restore();
1644   window1->Minimize();
1645   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1646
1647   // both minimized => disable auto hide
1648   window2->Minimize();
1649   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1650
1651   // Test moving windows to/from other display.
1652   window2->Restore();
1653   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1654   // Move to second display.
1655   window2->SetBounds(gfx::Rect(850, 50, 50, 50));
1656   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1657   // Move back to primary display.
1658   window2->SetBounds(gfx::Rect(50, 50, 50, 50));
1659   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1660 }
1661
1662 // Test that the shelf animates back to its normal position upon a user
1663 // completing a gesture drag.
1664 TEST_F(ShelfLayoutManagerTest, ShelfAnimatesWhenGestureComplete) {
1665   if (!SupportsHostWindowResize())
1666     return;
1667
1668   // Test the shelf animates back to its original visible bounds when it is
1669   // dragged when there are no visible windows.
1670   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1671   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1672   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1673   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1674   gfx::Rect visible_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
1675   {
1676     // Enable animations so that we can make sure that they occur.
1677     ui::ScopedAnimationDurationScaleMode regular_animations(
1678         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
1679
1680     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1681     gfx::Rect shelf_bounds_in_screen =
1682         GetShelfWidget()->GetWindowBoundsInScreen();
1683     gfx::Point start(shelf_bounds_in_screen.CenterPoint());
1684     gfx::Point end(start.x(), shelf_bounds_in_screen.bottom());
1685     generator.GestureScrollSequence(start, end,
1686         base::TimeDelta::FromMilliseconds(10), 5);
1687     EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1688     EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1689
1690     ShelfAnimationWaiter waiter(visible_bounds);
1691     // Wait till the animation completes and check that it occurred.
1692     waiter.WaitTillDoneAnimating();
1693     EXPECT_TRUE(waiter.WasValidAnimation());
1694   }
1695
1696   // Create a visible window so auto-hide behavior is enforced.
1697   CreateTestWidget();
1698
1699   // Get the bounds of the shelf when it is hidden.
1700   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1701   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1702   gfx::Rect auto_hidden_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
1703
1704   {
1705     // Enable the animations so that we can make sure they do occur.
1706     ui::ScopedAnimationDurationScaleMode regular_animations(
1707         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
1708
1709     gfx::Point start =
1710         GetShelfWidget()->GetWindowBoundsInScreen().CenterPoint();
1711     gfx::Point end(start.x(), start.y() - 100);
1712     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1713
1714     // Test that the shelf animates to the visible bounds after a swipe up on
1715     // the auto hidden shelf.
1716     generator.GestureScrollSequence(start, end,
1717         base::TimeDelta::FromMilliseconds(10), 1);
1718     EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1719     ShelfAnimationWaiter waiter1(visible_bounds);
1720     waiter1.WaitTillDoneAnimating();
1721     EXPECT_TRUE(waiter1.WasValidAnimation());
1722
1723     // Test that the shelf animates to the auto hidden bounds after a swipe up
1724     // on the visible shelf.
1725     EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1726     generator.GestureScrollSequence(start, end,
1727         base::TimeDelta::FromMilliseconds(10), 1);
1728     EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1729     EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1730     ShelfAnimationWaiter waiter2(auto_hidden_bounds);
1731     waiter2.WaitTillDoneAnimating();
1732     EXPECT_TRUE(waiter2.WasValidAnimation());
1733   }
1734 }
1735
1736 TEST_F(ShelfLayoutManagerTest, GestureRevealsTrayBubble) {
1737   if (!SupportsHostWindowResize())
1738     return;
1739
1740   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1741   shelf->LayoutShelf();
1742
1743   // Create a visible window so auto-hide behavior is enforced.
1744   CreateTestWidget();
1745
1746   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1747   SystemTray* tray = GetSystemTray();
1748
1749   // First, make sure the shelf is visible.
1750   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1751   EXPECT_FALSE(tray->HasSystemBubble());
1752
1753   // Now, drag up on the tray to show the bubble.
1754   gfx::Point start = GetShelfWidget()->status_area_widget()->
1755       GetWindowBoundsInScreen().CenterPoint();
1756   gfx::Point end(start.x(), start.y() - 100);
1757   generator.GestureScrollSequence(start, end,
1758       base::TimeDelta::FromMilliseconds(10), 1);
1759   EXPECT_TRUE(tray->HasSystemBubble());
1760   tray->CloseSystemBubble();
1761   RunAllPendingInMessageLoop();
1762   EXPECT_FALSE(tray->HasSystemBubble());
1763
1764   // Drag again, but only a small amount, and slowly. The bubble should not be
1765   // visible.
1766   end.set_y(start.y() - 30);
1767   generator.GestureScrollSequence(start, end,
1768       base::TimeDelta::FromMilliseconds(500), 100);
1769   EXPECT_FALSE(tray->HasSystemBubble());
1770
1771   // Now, hide the shelf.
1772   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1773
1774   // Start a drag from the bezel, and drag up to show both the shelf and the
1775   // tray bubble.
1776   start.set_y(start.y() + 100);
1777   end.set_y(start.y() - 400);
1778   generator.GestureScrollSequence(start, end,
1779       base::TimeDelta::FromMilliseconds(10), 1);
1780   EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state());
1781   EXPECT_TRUE(tray->HasSystemBubble());
1782 }
1783
1784 TEST_F(ShelfLayoutManagerTest, ShelfFlickerOnTrayActivation) {
1785   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1786
1787   // Create a visible window so auto-hide behavior is enforced.
1788   CreateTestWidget();
1789
1790   // Turn on auto-hide for the shelf.
1791   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1792   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1793   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
1794
1795   // Show the status menu. That should make the shelf visible again.
1796   Shell::GetInstance()->accelerator_controller()->PerformAction(
1797       SHOW_SYSTEM_TRAY_BUBBLE, ui::Accelerator());
1798   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
1799   EXPECT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->auto_hide_state());
1800   EXPECT_TRUE(GetSystemTray()->HasSystemBubble());
1801 }
1802
1803 TEST_F(ShelfLayoutManagerTest, WorkAreaChangeWorkspace) {
1804   // Make sure the shelf is always visible.
1805   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1806   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1807   shelf->LayoutShelf();
1808
1809   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
1810   params.bounds = gfx::Rect(0, 0, 200, 200);
1811   params.context = CurrentContext();
1812   views::Widget* widget_one = CreateTestWidgetWithParams(params);
1813   widget_one->Maximize();
1814
1815   views::Widget* widget_two = CreateTestWidgetWithParams(params);
1816   widget_two->Maximize();
1817   widget_two->Activate();
1818
1819   // Both windows are maximized. They should be of the same size.
1820   EXPECT_EQ(widget_one->GetNativeWindow()->bounds().ToString(),
1821             widget_two->GetNativeWindow()->bounds().ToString());
1822   int area_when_shelf_shown =
1823       widget_one->GetNativeWindow()->bounds().size().GetArea();
1824
1825   // Now hide the shelf.
1826   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1827
1828   // Both windows should be resized according to the shelf status.
1829   EXPECT_EQ(widget_one->GetNativeWindow()->bounds().ToString(),
1830             widget_two->GetNativeWindow()->bounds().ToString());
1831   // Resized to small.
1832   EXPECT_LT(area_when_shelf_shown,
1833             widget_one->GetNativeWindow()->bounds().size().GetArea());
1834
1835   // Now show the shelf.
1836   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1837
1838   // Again both windows should be of the same size.
1839   EXPECT_EQ(widget_one->GetNativeWindow()->bounds().ToString(),
1840             widget_two->GetNativeWindow()->bounds().ToString());
1841   EXPECT_EQ(area_when_shelf_shown,
1842             widget_one->GetNativeWindow()->bounds().size().GetArea());
1843 }
1844
1845 // Confirm that the shelf is dimmed only when content is maximized and
1846 // shelf is not autohidden.
1847 TEST_F(ShelfLayoutManagerTest, Dimming) {
1848   GetShelfLayoutManager()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1849   scoped_ptr<aura::Window> w1(CreateTestWindow());
1850   w1->Show();
1851   wm::ActivateWindow(w1.get());
1852
1853   // Normal window doesn't dim shelf.
1854   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
1855   ShelfWidget* shelf = GetShelfWidget();
1856   EXPECT_FALSE(shelf->GetDimsShelf());
1857
1858   // Maximized window does.
1859   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1860   EXPECT_TRUE(shelf->GetDimsShelf());
1861
1862   // Change back to normal stops dimming.
1863   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
1864   EXPECT_FALSE(shelf->GetDimsShelf());
1865
1866   // Changing back to maximized dims again.
1867   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1868   EXPECT_TRUE(shelf->GetDimsShelf());
1869
1870   // Changing shelf to autohide stops dimming.
1871   GetShelfLayoutManager()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1872   EXPECT_FALSE(shelf->GetDimsShelf());
1873 }
1874
1875 // Make sure that the shelf will not hide if the mouse is between a bubble and
1876 // the shelf.
1877 TEST_F(ShelfLayoutManagerTest, BubbleEnlargesShelfMouseHitArea) {
1878   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1879   StatusAreaWidget* status_area_widget =
1880       Shell::GetPrimaryRootWindowController()->shelf()->status_area_widget();
1881   SystemTray* tray = GetSystemTray();
1882
1883   // Create a visible window so auto-hide behavior is enforced.
1884   CreateTestWidget();
1885
1886   shelf->LayoutShelf();
1887   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1888
1889   // Make two iterations - first without a message bubble which should make
1890   // the shelf disappear and then with a message bubble which should keep it
1891   // visible.
1892   for (int i = 0; i < 2; i++) {
1893     // Make sure the shelf is visible and position the mouse over it. Then
1894     // allow auto hide.
1895     shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
1896     EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1897     gfx::Point center =
1898         status_area_widget->GetWindowBoundsInScreen().CenterPoint();
1899     generator.MoveMouseTo(center.x(), center.y());
1900     shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1901     EXPECT_TRUE(shelf->IsVisible());
1902     if (!i) {
1903       // In our first iteration we make sure there is no bubble.
1904       tray->CloseSystemBubble();
1905       EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1906     } else {
1907       // In our second iteration we show a bubble.
1908       TestItem *item = new TestItem;
1909       tray->AddTrayItem(item);
1910       tray->ShowNotificationView(item);
1911       EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
1912     }
1913     // Move the pointer over the edge of the shelf.
1914     generator.MoveMouseTo(
1915         center.x(), status_area_widget->GetWindowBoundsInScreen().y() - 8);
1916     shelf->UpdateVisibilityState();
1917     if (i) {
1918       EXPECT_TRUE(shelf->IsVisible());
1919       EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
1920     } else {
1921       EXPECT_FALSE(shelf->IsVisible());
1922       EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1923     }
1924   }
1925 }
1926
1927 TEST_F(ShelfLayoutManagerTest, ShelfBackgroundColor) {
1928   EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
1929
1930   scoped_ptr<aura::Window> w1(CreateTestWindow());
1931   w1->Show();
1932   wm::ActivateWindow(w1.get());
1933   EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
1934   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1935   EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
1936
1937   scoped_ptr<aura::Window> w2(CreateTestWindow());
1938   w2->Show();
1939   wm::ActivateWindow(w2.get());
1940   // Overlaps with shelf.
1941   w2->SetBounds(GetShelfLayoutManager()->GetIdealBounds());
1942
1943   // Still background is 'maximized'.
1944   EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
1945
1946   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
1947   EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
1948   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
1949   EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
1950
1951   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1952   EXPECT_EQ(SHELF_BACKGROUND_MAXIMIZED, GetShelfWidget()->GetBackgroundType());
1953   w1.reset();
1954   EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget()->GetBackgroundType());
1955 }
1956
1957 // Verify that the shelf doesn't have the opaque background if it's auto-hide
1958 // status.
1959 TEST_F(ShelfLayoutManagerTest, ShelfBackgroundColorAutoHide) {
1960   EXPECT_EQ(SHELF_BACKGROUND_DEFAULT, GetShelfWidget ()->GetBackgroundType());
1961
1962   GetShelfLayoutManager()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
1963   scoped_ptr<aura::Window> w1(CreateTestWindow());
1964   w1->Show();
1965   wm::ActivateWindow(w1.get());
1966   EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
1967   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
1968   EXPECT_EQ(SHELF_BACKGROUND_OVERLAP, GetShelfWidget()->GetBackgroundType());
1969 }
1970
1971 #if defined(OS_CHROMEOS)
1972 #define MAYBE_StatusAreaHitBoxCoversEdge StatusAreaHitBoxCoversEdge
1973 #else
1974 #define MAYBE_StatusAreaHitBoxCoversEdge DISABLED_StatusAreaHitBoxCoversEdge
1975 #endif
1976
1977 // Verify the hit bounds of the status area extend to the edge of the shelf.
1978 TEST_F(ShelfLayoutManagerTest, MAYBE_StatusAreaHitBoxCoversEdge) {
1979   UpdateDisplay("400x400");
1980   ShelfLayoutManager* shelf = GetShelfLayoutManager();
1981   StatusAreaWidget* status_area_widget =
1982       Shell::GetPrimaryRootWindowController()->shelf()->status_area_widget();
1983   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
1984   generator.MoveMouseTo(399,399);
1985
1986   // Test bottom right pixel for bottom alignment.
1987   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1988   generator.ClickLeftButton();
1989   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
1990   generator.ClickLeftButton();
1991   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1992
1993   // Test bottom right pixel for right alignment.
1994   shelf->SetAlignment(SHELF_ALIGNMENT_RIGHT);
1995   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
1996   generator.ClickLeftButton();
1997   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
1998   generator.ClickLeftButton();
1999   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
2000
2001   // Test bottom left pixel for left alignment.
2002   generator.MoveMouseTo(0, 399);
2003   shelf->SetAlignment(SHELF_ALIGNMENT_LEFT);
2004   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
2005   generator.ClickLeftButton();
2006   EXPECT_TRUE(status_area_widget->IsMessageBubbleShown());
2007   generator.ClickLeftButton();
2008   EXPECT_FALSE(status_area_widget->IsMessageBubbleShown());
2009 }
2010
2011 // Tests that when the auto-hide behaviour is changed during an animation the
2012 // target bounds are updated to reflect the new state.
2013 TEST_F(ShelfLayoutManagerTest,
2014        ShelfAutoHideToggleDuringAnimationUpdatesBounds) {
2015   ShelfLayoutManager* shelf_manager = GetShelfLayoutManager();
2016   aura::Window* status_window = GetShelfWidget()->status_area_widget()->
2017       GetNativeView();
2018   gfx::Rect initial_bounds = status_window->bounds();
2019
2020   ui::ScopedAnimationDurationScaleMode regular_animations(
2021       ui::ScopedAnimationDurationScaleMode::SLOW_DURATION);
2022   shelf_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN);
2023   gfx::Rect hide_target_bounds =  status_window->GetTargetBounds();
2024   EXPECT_GT(hide_target_bounds.y(), initial_bounds.y());
2025
2026   shelf_manager->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
2027   gfx::Rect reshow_target_bounds = status_window->GetTargetBounds();
2028   EXPECT_EQ(initial_bounds, reshow_target_bounds);
2029 }
2030
2031 }  // namespace ash