src/ash/wm/panels/panel_window_resizer_unittest.cc

   1 // Copyright (c) 2013 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/wm/panels/panel_window_resizer.h"
   6
   7 #include "ash/root_window_controller.h"
   8 #include "ash/shelf/shelf.h"
   9 #include "ash/shelf/shelf_layout_manager.h"
  10 #include "ash/shelf/shelf_model.h"
  11 #include "ash/shelf/shelf_types.h"
  12 #include "ash/shelf/shelf_util.h"
  13 #include "ash/shelf/shelf_widget.h"
  14 #include "ash/shell.h"
  15 #include "ash/shell_window_ids.h"
  16 #include "ash/test/ash_test_base.h"
  17 #include "ash/test/cursor_manager_test_api.h"
  18 #include "ash/test/shell_test_api.h"
  19 #include "ash/test/test_shelf_delegate.h"
  20 #include "ash/wm/drag_window_resizer.h"
  21 #include "ash/wm/panels/panel_layout_manager.h"
  22 #include "ash/wm/window_state.h"
  23 #include "ash/wm/wm_event.h"
  24 #include "base/win/windows_version.h"
  25 #include "ui/aura/client/aura_constants.h"
  26 #include "ui/aura/window_event_dispatcher.h"
  27 #include "ui/base/hit_test.h"
  28 #include "ui/base/l10n/l10n_util.h"
  29 #include "ui/base/ui_base_types.h"
  30 #include "ui/views/widget/widget.h"
  31 #include "ui/wm/core/window_util.h"
  32
  33 namespace ash {
  34
  35 class PanelWindowResizerTest : public test::AshTestBase {
  36  public:
  37   PanelWindowResizerTest() {}
  38   virtual ~PanelWindowResizerTest() {}
  39
  40   virtual void SetUp() OVERRIDE {
  41     AshTestBase::SetUp();
  42     UpdateDisplay("600x400");
  43     test::ShellTestApi test_api(Shell::GetInstance());
  44     model_ = test_api.shelf_model();
  45     shelf_delegate_ = test::TestShelfDelegate::instance();
  46   }
  47
  48   virtual void TearDown() OVERRIDE {
  49     AshTestBase::TearDown();
  50   }
  51
  52  protected:
  53   gfx::Point CalculateDragPoint(const WindowResizer& resizer,
  54                                 int delta_x,
  55                                 int delta_y) const {
  56     gfx::Point location = resizer.GetInitialLocation();
  57     location.set_x(location.x() + delta_x);
  58     location.set_y(location.y() + delta_y);
  59     return location;
  60   }
  61
  62   aura::Window* CreatePanelWindow(const gfx::Point& origin) {
  63     gfx::Rect bounds(origin, gfx::Size(101, 101));
  64     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
  65         NULL, ui::wm::WINDOW_TYPE_PANEL, 0, bounds);
  66     shelf_delegate_->AddShelfItem(window);
  67     return window;
  68   }
  69
  70   void DragStart(aura::Window* window) {
  71     resizer_.reset(CreateWindowResizer(
  72         window,
  73         window->bounds().origin(),
  74         HTCAPTION,
  75         aura::client::WINDOW_MOVE_SOURCE_MOUSE).release());
  76     ASSERT_TRUE(resizer_.get());
  77   }
  78
  79   void DragMove(int dx, int dy) {
  80     resizer_->Drag(CalculateDragPoint(*resizer_, dx, dy), 0);
  81   }
  82
  83   void DragEnd() {
  84     resizer_->CompleteDrag();
  85     resizer_.reset();
  86   }
  87
  88   void DragRevert() {
  89     resizer_->RevertDrag();
  90     resizer_.reset();
  91   }
  92
  93   // Test dragging the panel slightly, then detaching, and then reattaching
  94   // dragging out by the vector (dx, dy).
  95   void DetachReattachTest(aura::Window* window, int dx, int dy) {
  96     wm::WindowState* window_state = wm::GetWindowState(window);
  97     EXPECT_TRUE(window_state->panel_attached());
  98     aura::Window* root_window = window->GetRootWindow();
  99     EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 100     DragStart(window);
 101     gfx::Rect initial_bounds = window->GetBoundsInScreen();
 102
 103     // Drag the panel slightly. The window should still be snapped to the
 104     // launcher.
 105     DragMove(dx * 5, dy * 5);
 106     EXPECT_EQ(initial_bounds.x(), window->GetBoundsInScreen().x());
 107     EXPECT_EQ(initial_bounds.y(), window->GetBoundsInScreen().y());
 108
 109     // Drag further out and the window should now move to the cursor.
 110     DragMove(dx * 100, dy * 100);
 111     EXPECT_EQ(initial_bounds.x() + dx * 100, window->GetBoundsInScreen().x());
 112     EXPECT_EQ(initial_bounds.y() + dy * 100, window->GetBoundsInScreen().y());
 113
 114     // The panel should be detached when the drag completes.
 115     DragEnd();
 116
 117     EXPECT_FALSE(window_state->panel_attached());
 118     EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 119     EXPECT_EQ(root_window, window->GetRootWindow());
 120
 121     DragStart(window);
 122     // Drag the panel down.
 123     DragMove(dx * -95, dy * -95);
 124     // Release the mouse and the panel should be reattached.
 125     DragEnd();
 126
 127     // The panel should be reattached and have snapped to the launcher.
 128     EXPECT_TRUE(window_state->panel_attached());
 129     EXPECT_EQ(initial_bounds.x(), window->GetBoundsInScreen().x());
 130     EXPECT_EQ(initial_bounds.y(), window->GetBoundsInScreen().y());
 131     EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 132   }
 133
 134   void TestWindowOrder(const std::vector<aura::Window*>& window_order) {
 135     int panel_index = model_->FirstPanelIndex();
 136     EXPECT_EQ((int)(panel_index + window_order.size()), model_->item_count());
 137     for (std::vector<aura::Window*>::const_iterator iter =
 138          window_order.begin(); iter != window_order.end();
 139          ++iter, ++panel_index) {
 140       ShelfID id = GetShelfIDForWindow(*iter);
 141       EXPECT_EQ(id, model_->items()[panel_index].id);
 142     }
 143   }
 144
 145   // Test dragging panel window along the shelf and verify that panel icons
 146   // are reordered appropriately.
 147   void DragAlongShelfReorder(int dx, int dy) {
 148     gfx::Point origin(0, 0);
 149     scoped_ptr<aura::Window> w1(CreatePanelWindow(origin));
 150     scoped_ptr<aura::Window> w2(CreatePanelWindow(origin));
 151     std::vector<aura::Window*> window_order_original;
 152     std::vector<aura::Window*> window_order_swapped;
 153     window_order_original.push_back(w1.get());
 154     window_order_original.push_back(w2.get());
 155     window_order_swapped.push_back(w2.get());
 156     window_order_swapped.push_back(w1.get());
 157     TestWindowOrder(window_order_original);
 158
 159     // Drag window #2 to the beginning of the shelf.
 160     DragStart(w2.get());
 161     DragMove(400 * dx, 400 * dy);
 162     TestWindowOrder(window_order_swapped);
 163     DragEnd();
 164
 165     // Expect swapped window order.
 166     TestWindowOrder(window_order_swapped);
 167
 168     // Drag window #2 back to the end.
 169     DragStart(w2.get());
 170     DragMove(-400 * dx, -400 * dy);
 171     TestWindowOrder(window_order_original);
 172     DragEnd();
 173
 174     // Expect original order.
 175     TestWindowOrder(window_order_original);
 176   }
 177
 178  private:
 179   scoped_ptr<WindowResizer> resizer_;
 180   PanelLayoutManager* panel_layout_manager_;
 181   ShelfModel* model_;
 182   test::TestShelfDelegate* shelf_delegate_;
 183
 184   DISALLOW_COPY_AND_ASSIGN(PanelWindowResizerTest);
 185 };
 186
 187 class PanelWindowResizerTextDirectionTest
 188     : public PanelWindowResizerTest,
 189       public testing::WithParamInterface<bool> {
 190  public:
 191   PanelWindowResizerTextDirectionTest() : is_rtl_(GetParam()) {}
 192   virtual ~PanelWindowResizerTextDirectionTest() {}
 193
 194   virtual void SetUp() OVERRIDE {
 195     original_locale = l10n_util::GetApplicationLocale(std::string());
 196     if (is_rtl_)
 197       base::i18n::SetICUDefaultLocale("he");
 198     PanelWindowResizerTest::SetUp();
 199     ASSERT_EQ(is_rtl_, base::i18n::IsRTL());
 200   }
 201
 202   virtual void TearDown() OVERRIDE {
 203     if (is_rtl_)
 204       base::i18n::SetICUDefaultLocale(original_locale);
 205     PanelWindowResizerTest::TearDown();
 206   }
 207
 208  private:
 209   bool is_rtl_;
 210   std::string original_locale;
 211
 212   DISALLOW_COPY_AND_ASSIGN(PanelWindowResizerTextDirectionTest);
 213 };
 214
 215 // PanelLayoutManager and PanelWindowResizer should work if panels have
 216 // transient children of supported types.
 217 class PanelWindowResizerTransientTest
 218     : public PanelWindowResizerTest,
 219       public testing::WithParamInterface<ui::wm::WindowType> {
 220  public:
 221   PanelWindowResizerTransientTest() : transient_window_type_(GetParam()) {}
 222   virtual ~PanelWindowResizerTransientTest() {}
 223
 224  protected:
 225   ui::wm::WindowType transient_window_type_;
 226
 227  private:
 228   DISALLOW_COPY_AND_ASSIGN(PanelWindowResizerTransientTest);
 229 };
 230
 231 // Verifies a window can be dragged from the panel and detached and then
 232 // reattached.
 233 TEST_F(PanelWindowResizerTest, PanelDetachReattachBottom) {
 234  if (!SupportsHostWindowResize())
 235     return;
 236
 237   scoped_ptr<aura::Window> window(
 238       CreatePanelWindow(gfx::Point(0, 0)));
 239   DetachReattachTest(window.get(), 0, -1);
 240 }
 241
 242 TEST_F(PanelWindowResizerTest, PanelDetachReattachLeft) {
 243  if (!SupportsHostWindowResize())
 244     return;
 245
 246   ash::Shell* shell = ash::Shell::GetInstance();
 247   shell->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, shell->GetPrimaryRootWindow());
 248   scoped_ptr<aura::Window> window(
 249       CreatePanelWindow(gfx::Point(0, 0)));
 250   DetachReattachTest(window.get(), 1, 0);
 251 }
 252
 253 TEST_F(PanelWindowResizerTest, PanelDetachReattachRight) {
 254   if (!SupportsHostWindowResize())
 255     return;
 256
 257   ash::Shell* shell = ash::Shell::GetInstance();
 258   shell->SetShelfAlignment(SHELF_ALIGNMENT_RIGHT,
 259                            shell->GetPrimaryRootWindow());
 260   scoped_ptr<aura::Window> window(
 261       CreatePanelWindow(gfx::Point(0, 0)));
 262   DetachReattachTest(window.get(), -1, 0);
 263 }
 264
 265 TEST_F(PanelWindowResizerTest, PanelDetachReattachTop) {
 266  if (!SupportsHostWindowResize())
 267     return;
 268
 269   ash::Shell* shell = ash::Shell::GetInstance();
 270   shell->SetShelfAlignment(SHELF_ALIGNMENT_TOP, shell->GetPrimaryRootWindow());
 271   scoped_ptr<aura::Window> window(
 272       CreatePanelWindow(gfx::Point(0, 0)));
 273   DetachReattachTest(window.get(), 0, 1);
 274 }
 275
 276 TEST_F(PanelWindowResizerTest, PanelDetachReattachMultipleDisplays) {
 277   if (!SupportsMultipleDisplays())
 278     return;
 279
 280   UpdateDisplay("600x400,600x400");
 281   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 282   scoped_ptr<aura::Window> window(
 283       CreatePanelWindow(gfx::Point(600, 0)));
 284   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 285   DetachReattachTest(window.get(), 0, -1);
 286 }
 287
 288 TEST_F(PanelWindowResizerTest, DetachThenDragAcrossDisplays) {
 289   if (!SupportsMultipleDisplays())
 290     return;
 291
 292   UpdateDisplay("600x400,600x400");
 293   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 294   scoped_ptr<aura::Window> window(
 295       CreatePanelWindow(gfx::Point(0, 0)));
 296   gfx::Rect initial_bounds = window->GetBoundsInScreen();
 297   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 298   DragStart(window.get());
 299   DragMove(0, -100);
 300   DragEnd();
 301   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 302   EXPECT_EQ(initial_bounds.x(), window->GetBoundsInScreen().x());
 303   EXPECT_EQ(initial_bounds.y() - 100, window->GetBoundsInScreen().y());
 304   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 305   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 306
 307   DragStart(window.get());
 308   DragMove(500, 0);
 309   DragEnd();
 310   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 311   EXPECT_EQ(initial_bounds.x() + 500, window->GetBoundsInScreen().x());
 312   EXPECT_EQ(initial_bounds.y() - 100, window->GetBoundsInScreen().y());
 313   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 314   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 315 }
 316
 317 TEST_F(PanelWindowResizerTest, DetachAcrossDisplays) {
 318   if (!SupportsMultipleDisplays())
 319     return;
 320
 321   UpdateDisplay("600x400,600x400");
 322   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 323   scoped_ptr<aura::Window> window(
 324       CreatePanelWindow(gfx::Point(0, 0)));
 325   gfx::Rect initial_bounds = window->GetBoundsInScreen();
 326   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 327   DragStart(window.get());
 328   DragMove(500, -100);
 329   DragEnd();
 330   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 331   EXPECT_EQ(initial_bounds.x() + 500, window->GetBoundsInScreen().x());
 332   EXPECT_EQ(initial_bounds.y() - 100, window->GetBoundsInScreen().y());
 333   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 334   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 335 }
 336
 337 TEST_F(PanelWindowResizerTest, DetachThenAttachToSecondDisplay) {
 338   if (!SupportsMultipleDisplays())
 339     return;
 340
 341   UpdateDisplay("600x400,600x600");
 342   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 343   scoped_ptr<aura::Window> window(
 344       CreatePanelWindow(gfx::Point(0, 0)));
 345   gfx::Rect initial_bounds = window->GetBoundsInScreen();
 346   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 347
 348   // Detach the window.
 349   DragStart(window.get());
 350   DragMove(0, -100);
 351   DragEnd();
 352   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 353   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 354
 355   // Drag the window just above the other display's launcher.
 356   DragStart(window.get());
 357   DragMove(500, 295);
 358   EXPECT_EQ(initial_bounds.x() + 500, window->GetBoundsInScreen().x());
 359
 360   // Should stick to other launcher.
 361   EXPECT_EQ(initial_bounds.y() + 200, window->GetBoundsInScreen().y());
 362   DragEnd();
 363
 364   // When dropped should move to second display's panel container.
 365   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 366   EXPECT_TRUE(wm::GetWindowState(window.get())->panel_attached());
 367   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 368 }
 369
 370 TEST_F(PanelWindowResizerTest, AttachToSecondDisplay) {
 371   if (!SupportsMultipleDisplays())
 372     return;
 373
 374   UpdateDisplay("600x400,600x600");
 375   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 376   scoped_ptr<aura::Window> window(
 377       CreatePanelWindow(gfx::Point(0, 0)));
 378   gfx::Rect initial_bounds = window->GetBoundsInScreen();
 379   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 380
 381   // Drag the window just above the other display's launcher.
 382   DragStart(window.get());
 383   DragMove(500, 195);
 384   EXPECT_EQ(initial_bounds.x() + 500, window->GetBoundsInScreen().x());
 385
 386   // Should stick to other launcher.
 387   EXPECT_EQ(initial_bounds.y() + 200, window->GetBoundsInScreen().y());
 388   DragEnd();
 389
 390   // When dropped should move to second display's panel container.
 391   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 392   EXPECT_TRUE(wm::GetWindowState(window.get())->panel_attached());
 393   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 394 }
 395
 396 TEST_F(PanelWindowResizerTest, AttachToSecondFullscreenDisplay) {
 397   if (!SupportsMultipleDisplays())
 398     return;
 399
 400   UpdateDisplay("600x400,600x600");
 401   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
 402   scoped_ptr<aura::Window> window(
 403       CreatePanelWindow(gfx::Point(0, 0)));
 404   scoped_ptr<aura::Window> fullscreen(
 405       CreateTestWindowInShellWithBounds(gfx::Rect(600, 0, 101, 101)));
 406   wm::GetWindowState(fullscreen.get())->Activate();
 407   const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
 408   wm::GetWindowState(fullscreen.get())->OnWMEvent(&event);
 409   EXPECT_TRUE(wm::GetWindowState(fullscreen.get())->IsFullscreen());
 410
 411   gfx::Rect initial_bounds = window->GetBoundsInScreen();
 412   EXPECT_EQ(root_windows[0], window->GetRootWindow());
 413
 414   // Activate and drag the window to the other display's launcher.
 415   wm::GetWindowState(window.get())->Activate();
 416   DragStart(window.get());
 417   DragMove(500, 250);
 418   EXPECT_EQ(initial_bounds.x() + 500, window->GetBoundsInScreen().x());
 419   EXPECT_GT(window->GetBoundsInScreen().y(),
 420             initial_bounds.y() + 200);
 421   DragEnd();
 422
 423   // When dropped should move to second display's panel container.
 424   EXPECT_EQ(root_windows[1], window->GetRootWindow());
 425   EXPECT_TRUE(wm::GetWindowState(window.get())->panel_attached());
 426   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 427   EXPECT_TRUE(window->IsVisible());
 428   EXPECT_TRUE(wm::GetWindowState(window.get())->IsActive());
 429   EXPECT_EQ(initial_bounds.y() + 200, window->GetBoundsInScreen().y());
 430 }
 431
 432 TEST_F(PanelWindowResizerTest, RevertDragRestoresAttachment) {
 433   scoped_ptr<aura::Window> window(
 434       CreatePanelWindow(gfx::Point(0, 0)));
 435   EXPECT_TRUE(wm::GetWindowState(window.get())->panel_attached());
 436   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 437   DragStart(window.get());
 438   DragMove(0, -100);
 439   DragRevert();
 440   EXPECT_TRUE(wm::GetWindowState(window.get())->panel_attached());
 441   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 442
 443   // Detach panel.
 444   DragStart(window.get());
 445   DragMove(0, -100);
 446   DragEnd();
 447   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 448   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 449
 450   // Drag back to launcher.
 451   DragStart(window.get());
 452   DragMove(0, 100);
 453
 454   // When the drag is reverted it should remain detached.
 455   DragRevert();
 456   EXPECT_FALSE(wm::GetWindowState(window.get())->panel_attached());
 457   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 458 }
 459
 460 TEST_F(PanelWindowResizerTest, DragMovesToPanelLayer) {
 461   scoped_ptr<aura::Window> window(CreatePanelWindow(gfx::Point(0, 0)));
 462   DragStart(window.get());
 463   DragMove(0, -100);
 464   DragEnd();
 465   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 466
 467   // While moving the panel window should be moved to the panel container.
 468   DragStart(window.get());
 469   DragMove(20, 0);
 470   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 471   DragEnd();
 472
 473   // When dropped it should return to the default container.
 474   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 475 }
 476
 477 TEST_P(PanelWindowResizerTextDirectionTest, DragReordersPanelsHorizontal) {
 478   if (!SupportsHostWindowResize())
 479     return;
 480
 481   DragAlongShelfReorder(base::i18n::IsRTL() ? 1 : -1, 0);
 482 }
 483
 484 TEST_F(PanelWindowResizerTest, DragReordersPanelsVertical) {
 485   if (!SupportsHostWindowResize())
 486     return;
 487
 488   ash::Shell* shell = ash::Shell::GetInstance();
 489   shell->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, shell->GetPrimaryRootWindow());
 490   DragAlongShelfReorder(0, -1);
 491 }
 492
 493 // Tests that panels can have transient children of different types.
 494 // The transient children should be reparented in sync with the panel.
 495 TEST_P(PanelWindowResizerTransientTest, PanelWithTransientChild) {
 496   if (!SupportsHostWindowResize())
 497     return;
 498
 499   scoped_ptr<aura::Window> window(CreatePanelWindow(gfx::Point(0, 0)));
 500   scoped_ptr<aura::Window> child(CreateTestWindowInShellWithDelegateAndType(
 501       NULL, transient_window_type_, 0, gfx::Rect(20, 20, 150, 40)));
 502   ::wm::AddTransientChild(window.get(), child.get());
 503   if (window->parent() != child->parent())
 504     window->parent()->AddChild(child.get());
 505   EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get()));
 506
 507   // Drag the child to the shelf. Its new position should not be overridden.
 508   const gfx::Rect attached_bounds(window->GetBoundsInScreen());
 509   const int dy = window->GetBoundsInScreen().bottom() -
 510       child->GetBoundsInScreen().bottom();
 511   DragStart(child.get());
 512   DragMove(50, dy);
 513   // While moving the transient child window should be in the panel container.
 514   EXPECT_EQ(kShellWindowId_PanelContainer, child->parent()->id());
 515   DragEnd();
 516   // Child should move, |window| should not.
 517   EXPECT_EQ(gfx::Point(20 + 50, 20 + dy).ToString(),
 518             child->GetBoundsInScreen().origin().ToString());
 519   EXPECT_EQ(attached_bounds.ToString(), window->GetBoundsInScreen().ToString());
 520
 521   // Drag the child along the the shelf past the |window|.
 522   // Its new position should not be overridden.
 523   DragStart(child.get());
 524   DragMove(350, 0);
 525   // While moving the transient child window should be in the panel container.
 526   EXPECT_EQ(kShellWindowId_PanelContainer, child->parent()->id());
 527   DragEnd();
 528   // |child| should move, |window| should not.
 529   EXPECT_EQ(gfx::Point(20 + 50 + 350, 20 + dy).ToString(),
 530             child->GetBoundsInScreen().origin().ToString());
 531   EXPECT_EQ(attached_bounds.ToString(), window->GetBoundsInScreen().ToString());
 532
 533   DragStart(window.get());
 534   DragMove(0, -100);
 535   // While moving the windows should be in the panel container.
 536   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 537   EXPECT_EQ(kShellWindowId_PanelContainer, child->parent()->id());
 538   DragEnd();
 539   // When dropped they should return to the default container.
 540   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 541   EXPECT_EQ(kShellWindowId_DefaultContainer, child->parent()->id());
 542
 543   // While moving the window and child should be moved to the panel container.
 544   DragStart(window.get());
 545   DragMove(20, 0);
 546   EXPECT_EQ(kShellWindowId_PanelContainer, window->parent()->id());
 547   EXPECT_EQ(kShellWindowId_PanelContainer, child->parent()->id());
 548   DragEnd();
 549
 550   // When dropped they should return to the default container.
 551   EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id());
 552   EXPECT_EQ(kShellWindowId_DefaultContainer, child->parent()->id());
 553 }
 554
 555 INSTANTIATE_TEST_CASE_P(LtrRtl, PanelWindowResizerTextDirectionTest,
 556                         testing::Bool());
 557 INSTANTIATE_TEST_CASE_P(NormalPanelPopup,
 558                         PanelWindowResizerTransientTest,
 559                         testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
 560                                         ui::wm::WINDOW_TYPE_PANEL,
 561                                         ui::wm::WINDOW_TYPE_POPUP));
 562
 563 }  // namespace ash