| OLD | NEW |
|---|
| (Empty) |
| 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 "base/message_loop.h" | |
| 6 #include "chrome/browser/ui/panels/old_base_panel_browser_test.h" | |
| 7 #include "chrome/browser/ui/panels/detached_panel_strip.h" | |
| 8 #include "chrome/browser/ui/panels/docked_panel_strip.h" | |
| 9 #include "chrome/browser/ui/panels/native_panel.h" | |
| 10 #include "chrome/browser/ui/panels/panel.h" | |
| 11 #include "chrome/browser/ui/panels/panel_drag_controller.h" | |
| 12 #include "chrome/browser/ui/panels/panel_manager.h" | |
| 13 | |
| 14 class OldPanelDragBrowserTest : public OldBasePanelBrowserTest { | |
| 15 public: | |
| 16 OldPanelDragBrowserTest() : OldBasePanelBrowserTest() { | |
| 17 } | |
| 18 | |
| 19 virtual ~OldPanelDragBrowserTest() { | |
| 20 } | |
| 21 | |
| 22 virtual void SetUpOnMainThread() OVERRIDE { | |
| 23 OldBasePanelBrowserTest::SetUpOnMainThread(); | |
| 24 | |
| 25 // All the tests here assume using mocked 800x600 screen area for the | |
| 26 // primary monitor. Do the check now. | |
| 27 gfx::Rect primary_screen_area = PanelManager::GetInstance()-> | |
| 28 display_settings_provider()->GetPrimaryScreenArea(); | |
| 29 DCHECK(primary_screen_area.width() == 800); | |
| 30 DCHECK(primary_screen_area.height() == 600); | |
| 31 } | |
| 32 | |
| 33 // Drag |panel| from its origin by the offset |delta|. | |
| 34 void DragPanelByDelta(Panel* panel, const gfx::Point& delta) { | |
| 35 scoped_ptr<NativePanelTesting> panel_testing( | |
| 36 CreateNativePanelTesting(panel)); | |
| 37 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 38 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 39 panel_testing->DragTitlebar(mouse_location.Add(delta)); | |
| 40 panel_testing->FinishDragTitlebar(); | |
| 41 } | |
| 42 | |
| 43 // Drag |panel| from its origin to |new_mouse_location|. | |
| 44 void DragPanelToMouseLocation(Panel* panel, | |
| 45 const gfx::Point& new_mouse_location) { | |
| 46 scoped_ptr<NativePanelTesting> panel_testing( | |
| 47 CreateNativePanelTesting(panel)); | |
| 48 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 49 panel_testing->PressLeftMouseButtonTitlebar(panel->GetBounds().origin()); | |
| 50 panel_testing->DragTitlebar(new_mouse_location); | |
| 51 panel_testing->FinishDragTitlebar(); | |
| 52 } | |
| 53 | |
| 54 static gfx::Point GetDragDeltaToRemainDocked() { | |
| 55 return gfx::Point( | |
| 56 -5, | |
| 57 -(PanelDragController::GetDetachDockedPanelThreshold() / 2)); | |
| 58 } | |
| 59 | |
| 60 static gfx::Point GetDragDeltaToDetach() { | |
| 61 return gfx::Point( | |
| 62 -20, | |
| 63 -(PanelDragController::GetDetachDockedPanelThreshold() + 20)); | |
| 64 } | |
| 65 | |
| 66 static gfx::Point GetDragDeltaToRemainDetached(Panel* panel) { | |
| 67 int distance = panel->manager()->docked_strip()->display_area().bottom() - | |
| 68 panel->GetBounds().bottom(); | |
| 69 return gfx::Point( | |
| 70 -5, | |
| 71 distance - PanelDragController::GetDockDetachedPanelThreshold() * 2); | |
| 72 } | |
| 73 | |
| 74 static gfx::Point GetDragDeltaToAttach(Panel* panel) { | |
| 75 int distance = panel->manager()->docked_strip()->display_area().bottom() - | |
| 76 panel->GetBounds().bottom(); | |
| 77 return gfx::Point( | |
| 78 -20, | |
| 79 distance - PanelDragController::GetDockDetachedPanelThreshold() / 2); | |
| 80 } | |
| 81 }; | |
| 82 | |
| 83 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragOneDockedPanel) { | |
| 84 static const int big_delta_x = 70; | |
| 85 static const int big_delta_y = 30; // Do not exceed the threshold to detach. | |
| 86 | |
| 87 Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 88 scoped_ptr<NativePanelTesting> panel_testing( | |
| 89 CreateNativePanelTesting(panel)); | |
| 90 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 91 | |
| 92 // Drag left. | |
| 93 gfx::Point mouse_location = panel_old_bounds.origin(); | |
| 94 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 95 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 96 | |
| 97 mouse_location.Offset(-big_delta_x, 0); | |
| 98 panel_testing->DragTitlebar(mouse_location); | |
| 99 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 100 panel_new_bounds.Offset(-big_delta_x, 0); | |
| 101 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 102 | |
| 103 panel_testing->FinishDragTitlebar(); | |
| 104 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 105 | |
| 106 // Drag left and cancel. | |
| 107 mouse_location = panel_old_bounds.origin(); | |
| 108 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 109 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 110 | |
| 111 mouse_location.Offset(-big_delta_x, 0); | |
| 112 panel_testing->DragTitlebar(mouse_location); | |
| 113 panel_new_bounds = panel_old_bounds; | |
| 114 panel_new_bounds.Offset(-big_delta_x, 0); | |
| 115 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 116 | |
| 117 panel_testing->CancelDragTitlebar(); | |
| 118 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 119 | |
| 120 // Drag right. | |
| 121 mouse_location = panel_old_bounds.origin(); | |
| 122 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 123 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 124 | |
| 125 mouse_location.Offset(big_delta_x, 0); | |
| 126 panel_testing->DragTitlebar(mouse_location); | |
| 127 panel_new_bounds = panel_old_bounds; | |
| 128 panel_new_bounds.Offset(big_delta_x, 0); | |
| 129 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 130 | |
| 131 panel_testing->FinishDragTitlebar(); | |
| 132 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 133 | |
| 134 // Drag right and up. Expect no vertical movement. | |
| 135 mouse_location = panel_old_bounds.origin(); | |
| 136 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 137 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 138 | |
| 139 mouse_location.Offset(big_delta_x, big_delta_y); | |
| 140 panel_testing->DragTitlebar(mouse_location); | |
| 141 panel_new_bounds = panel_old_bounds; | |
| 142 panel_new_bounds.Offset(big_delta_x, 0); | |
| 143 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 144 | |
| 145 panel_testing->FinishDragTitlebar(); | |
| 146 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 147 | |
| 148 // Drag up. Expect no movement on drag. | |
| 149 mouse_location = panel_old_bounds.origin(); | |
| 150 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 151 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 152 | |
| 153 mouse_location.Offset(0, -big_delta_y); | |
| 154 panel_testing->DragTitlebar(mouse_location); | |
| 155 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 156 | |
| 157 panel_testing->FinishDragTitlebar(); | |
| 158 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 159 | |
| 160 // Drag down. Expect no movement on drag. | |
| 161 mouse_location = panel_old_bounds.origin(); | |
| 162 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 163 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 164 | |
| 165 mouse_location.Offset(0, big_delta_y); | |
| 166 panel_testing->DragTitlebar(mouse_location); | |
| 167 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 168 | |
| 169 panel_testing->FinishDragTitlebar(); | |
| 170 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 171 | |
| 172 PanelManager::GetInstance()->CloseAll(); | |
| 173 } | |
| 174 | |
| 175 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragTwoDockedPanels) { | |
| 176 static const gfx::Point small_delta(10, 0); | |
| 177 | |
| 178 Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 179 Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 100, 100)); | |
| 180 scoped_ptr<NativePanelTesting> panel1_testing( | |
| 181 CreateNativePanelTesting(panel1)); | |
| 182 scoped_ptr<NativePanelTesting> panel2_testing( | |
| 183 CreateNativePanelTesting(panel2)); | |
| 184 gfx::Point position1 = panel1->GetBounds().origin(); | |
| 185 gfx::Point position2 = panel2->GetBounds().origin(); | |
| 186 | |
| 187 // Drag right panel towards left with small delta. | |
| 188 // Expect no shuffle: P1 P2 | |
| 189 gfx::Point mouse_location = position1; | |
| 190 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 191 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 192 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 193 | |
| 194 mouse_location = mouse_location.Subtract(small_delta); | |
| 195 panel1_testing->DragTitlebar(mouse_location); | |
| 196 EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); | |
| 197 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 198 | |
| 199 panel1_testing->FinishDragTitlebar(); | |
| 200 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 201 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 202 | |
| 203 // Drag right panel towards left with big delta. | |
| 204 // Expect shuffle: P2 P1 | |
| 205 mouse_location = position1; | |
| 206 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 207 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 208 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 209 | |
| 210 mouse_location = position2.Add(gfx::Point(1, 0)); | |
| 211 panel1_testing->DragTitlebar(mouse_location); | |
| 212 EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); | |
| 213 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 214 | |
| 215 panel1_testing->FinishDragTitlebar(); | |
| 216 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 217 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 218 | |
| 219 // Drag left panel towards right with small delta. | |
| 220 // Expect no shuffle: P2 P1 | |
| 221 mouse_location = position2; | |
| 222 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 223 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 224 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 225 | |
| 226 mouse_location = mouse_location.Add(small_delta); | |
| 227 panel1_testing->DragTitlebar(mouse_location); | |
| 228 EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); | |
| 229 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 230 | |
| 231 panel1_testing->FinishDragTitlebar(); | |
| 232 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 233 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 234 | |
| 235 // Drag left panel towards right with big delta. | |
| 236 // Expect shuffle: P1 P2 | |
| 237 mouse_location = position2; | |
| 238 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 239 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 240 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 241 | |
| 242 mouse_location = position1.Add(gfx::Point(1, 0)); | |
| 243 panel1_testing->DragTitlebar(mouse_location); | |
| 244 EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); | |
| 245 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 246 | |
| 247 panel1_testing->FinishDragTitlebar(); | |
| 248 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 249 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 250 | |
| 251 // Drag right panel towards left with big delta and then cancel the drag. | |
| 252 // Expect shuffle after drag: P2 P1 | |
| 253 // Expect shuffle after cancel: P1 P2 | |
| 254 mouse_location = position1; | |
| 255 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 256 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 257 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 258 | |
| 259 mouse_location = position2.Add(gfx::Point(1, 0)); | |
| 260 panel1_testing->DragTitlebar(mouse_location); | |
| 261 EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); | |
| 262 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 263 | |
| 264 panel1_testing->CancelDragTitlebar(); | |
| 265 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 266 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 267 | |
| 268 PanelManager::GetInstance()->CloseAll(); | |
| 269 } | |
| 270 | |
| 271 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragThreeDockedPanels) { | |
| 272 Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 273 Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 100, 100)); | |
| 274 Panel* panel3 = CreateDockedPanel("3", gfx::Rect(0, 0, 100, 100)); | |
| 275 scoped_ptr<NativePanelTesting> panel2_testing( | |
| 276 CreateNativePanelTesting(panel2)); | |
| 277 scoped_ptr<NativePanelTesting> panel3_testing( | |
| 278 CreateNativePanelTesting(panel3)); | |
| 279 gfx::Point position1 = panel1->GetBounds().origin(); | |
| 280 gfx::Point position2 = panel2->GetBounds().origin(); | |
| 281 gfx::Point position3 = panel3->GetBounds().origin(); | |
| 282 | |
| 283 // Drag leftmost panel to become the rightmost in 2 drags. Each drag will | |
| 284 // shuffle one panel. | |
| 285 // Expect shuffle after 1st drag: P1 P3 P2 | |
| 286 // Expect shuffle after 2nd drag: P3 P1 P2 | |
| 287 gfx::Point mouse_location = position3; | |
| 288 panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 289 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 290 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 291 EXPECT_EQ(position3, panel3->GetBounds().origin()); | |
| 292 | |
| 293 mouse_location = position2.Add(gfx::Point(1, 0)); | |
| 294 panel3_testing->DragTitlebar(mouse_location); | |
| 295 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 296 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 297 EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); | |
| 298 | |
| 299 mouse_location = position1.Add(gfx::Point(1, 0)); | |
| 300 panel3_testing->DragTitlebar(mouse_location); | |
| 301 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 302 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 303 EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); | |
| 304 | |
| 305 panel3_testing->FinishDragTitlebar(); | |
| 306 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 307 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 308 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 309 | |
| 310 // Drag rightmost panel to become the leftmost in 2 drags and then cancel the | |
| 311 // drag. Each drag will shuffle one panel and the cancellation will restore | |
| 312 // all panels. | |
| 313 // Expect shuffle after 1st drag: P1 P3 P2 | |
| 314 // Expect shuffle after 2nd drag: P1 P2 P3 | |
| 315 // Expect shuffle after cancel: P3 P1 P2 | |
| 316 mouse_location = position1; | |
| 317 panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 318 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 319 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 320 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 321 | |
| 322 mouse_location = position2.Add(gfx::Point(1, 0)); | |
| 323 panel3_testing->DragTitlebar(mouse_location); | |
| 324 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 325 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 326 EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); | |
| 327 | |
| 328 mouse_location = position3.Add(gfx::Point(1, 0)); | |
| 329 panel3_testing->DragTitlebar(mouse_location); | |
| 330 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 331 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 332 EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); | |
| 333 | |
| 334 panel3_testing->CancelDragTitlebar(); | |
| 335 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 336 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 337 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 338 | |
| 339 // Drag leftmost panel to become the rightmost in a single drag. The drag will | |
| 340 // shuffle 2 panels at a time. | |
| 341 // Expect shuffle: P2 P3 P1 | |
| 342 mouse_location = position3; | |
| 343 panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 344 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 345 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 346 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 347 | |
| 348 mouse_location = position1.Add(gfx::Point(1, 0)); | |
| 349 panel2_testing->DragTitlebar(mouse_location); | |
| 350 EXPECT_EQ(position3, panel1->GetBounds().origin()); | |
| 351 EXPECT_EQ(mouse_location, panel2->GetBounds().origin()); | |
| 352 EXPECT_EQ(position2, panel3->GetBounds().origin()); | |
| 353 | |
| 354 panel2_testing->FinishDragTitlebar(); | |
| 355 EXPECT_EQ(position3, panel1->GetBounds().origin()); | |
| 356 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 357 EXPECT_EQ(position2, panel3->GetBounds().origin()); | |
| 358 | |
| 359 // Drag rightmost panel to become the leftmost in a single drag. The drag will | |
| 360 // shuffle 2 panels at a time. | |
| 361 // Expect shuffle: P3 P1 P2 | |
| 362 mouse_location = position1; | |
| 363 panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 364 EXPECT_EQ(position3, panel1->GetBounds().origin()); | |
| 365 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 366 EXPECT_EQ(position2, panel3->GetBounds().origin()); | |
| 367 | |
| 368 mouse_location = position3.Add(gfx::Point(1, 0)); | |
| 369 panel2_testing->DragTitlebar(mouse_location); | |
| 370 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 371 EXPECT_EQ(mouse_location, panel2->GetBounds().origin()); | |
| 372 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 373 | |
| 374 panel2_testing->FinishDragTitlebar(); | |
| 375 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 376 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 377 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 378 | |
| 379 // Drag rightmost panel to become the leftmost in a single drag and then | |
| 380 // cancel the drag. The drag will shuffle 2 panels and the cancellation will | |
| 381 // restore all panels. | |
| 382 // Expect shuffle after drag: P1 P2 P3 | |
| 383 // Expect shuffle after cancel: P3 P1 P2 | |
| 384 mouse_location = position1; | |
| 385 panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 386 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 387 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 388 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 389 | |
| 390 mouse_location = position3.Add(gfx::Point(1, 0)); | |
| 391 panel3_testing->DragTitlebar(mouse_location); | |
| 392 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 393 EXPECT_EQ(position2, panel2->GetBounds().origin()); | |
| 394 EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); | |
| 395 | |
| 396 panel3_testing->CancelDragTitlebar(); | |
| 397 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 398 EXPECT_EQ(position3, panel2->GetBounds().origin()); | |
| 399 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 400 | |
| 401 PanelManager::GetInstance()->CloseAll(); | |
| 402 } | |
| 403 | |
| 404 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragMinimizedPanel) { | |
| 405 Panel* panel = CreatePanel("panel1"); | |
| 406 scoped_ptr<NativePanelTesting> panel_testing( | |
| 407 CreateNativePanelTesting(panel)); | |
| 408 | |
| 409 panel->Minimize(); | |
| 410 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); | |
| 411 | |
| 412 // Hover over minimized panel to bring up titlebar. | |
| 413 gfx::Point hover_point(panel->GetBounds().origin()); | |
| 414 MoveMouseAndWaitForExpansionStateChange(panel, hover_point); | |
| 415 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 416 | |
| 417 // Verify we can drag a minimized panel. | |
| 418 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 419 gfx::Point mouse_location = panel_old_bounds.origin(); | |
| 420 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 421 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 422 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 423 | |
| 424 mouse_location.Offset(-70, 0); | |
| 425 panel_testing->DragTitlebar(mouse_location); | |
| 426 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 427 panel_new_bounds.Offset(-70, 0); | |
| 428 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 429 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 430 | |
| 431 // Verify panel returns to fully minimized state after dragging ends once | |
| 432 // mouse moves away from panel. | |
| 433 panel_testing->FinishDragTitlebar(); | |
| 434 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 435 | |
| 436 MoveMouseAndWaitForExpansionStateChange(panel, mouse_location); | |
| 437 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); | |
| 438 | |
| 439 panel->Close(); | |
| 440 } | |
| 441 | |
| 442 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, | |
| 443 DragMinimizedPanelWhileDrawingAttention) { | |
| 444 Panel* panel = CreatePanel("panel1"); | |
| 445 scoped_ptr<NativePanelTesting> panel_testing( | |
| 446 CreateNativePanelTesting(panel)); | |
| 447 CreatePanel("panel2"); | |
| 448 | |
| 449 panel->Minimize(); | |
| 450 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); | |
| 451 | |
| 452 panel->FlashFrame(true); | |
| 453 EXPECT_TRUE(panel->IsDrawingAttention()); | |
| 454 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 455 | |
| 456 // Drag the panel. Verify panel stays in title-only state after attention is | |
| 457 // cleared because it is being dragged. | |
| 458 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 459 gfx::Point mouse_location = panel_old_bounds.origin(); | |
| 460 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 461 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 462 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 463 | |
| 464 mouse_location.Offset(-70, 0); | |
| 465 panel_testing->DragTitlebar(mouse_location); | |
| 466 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 467 panel_new_bounds.Offset(-70, 0); | |
| 468 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 469 | |
| 470 panel->FlashFrame(false); | |
| 471 EXPECT_FALSE(panel->IsDrawingAttention()); | |
| 472 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 473 | |
| 474 // Typical user scenario will detect the mouse in the panel | |
| 475 // after attention is cleared, causing titles to pop up, so | |
| 476 // we simulate that here. | |
| 477 MoveMouse(mouse_location); | |
| 478 | |
| 479 // Verify panel returns to fully minimized state after dragging ends once | |
| 480 // mouse moves away from the panel. | |
| 481 panel_testing->FinishDragTitlebar(); | |
| 482 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); | |
| 483 | |
| 484 mouse_location.Offset(0, -50); | |
| 485 MoveMouseAndWaitForExpansionStateChange(panel, mouse_location); | |
| 486 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); | |
| 487 | |
| 488 PanelManager::GetInstance()->CloseAll(); | |
| 489 } | |
| 490 | |
| 491 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, CloseDockedPanelOnDrag) { | |
| 492 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 493 PanelDragController* drag_controller = panel_manager->drag_controller(); | |
| 494 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 495 | |
| 496 // Create 4 docked panels. | |
| 497 // We have: P4 P3 P2 P1 | |
| 498 Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 100, 100)); | |
| 499 Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 100, 100)); | |
| 500 Panel* panel3 = CreatePanelWithBounds("Panel3", gfx::Rect(0, 0, 100, 100)); | |
| 501 Panel* panel4 = CreatePanelWithBounds("Panel4", gfx::Rect(0, 0, 100, 100)); | |
| 502 ASSERT_EQ(4, docked_strip->num_panels()); | |
| 503 | |
| 504 scoped_ptr<NativePanelTesting> panel1_testing( | |
| 505 CreateNativePanelTesting(panel1)); | |
| 506 gfx::Point position1 = panel1->GetBounds().origin(); | |
| 507 gfx::Point position2 = panel2->GetBounds().origin(); | |
| 508 gfx::Point position3 = panel3->GetBounds().origin(); | |
| 509 gfx::Point position4 = panel4->GetBounds().origin(); | |
| 510 | |
| 511 // Test the scenario: drag a panel, close another panel, cancel the drag. | |
| 512 { | |
| 513 std::vector<Panel*> panels; | |
| 514 gfx::Point panel1_new_position = position1; | |
| 515 panel1_new_position.Offset(-500, 0); | |
| 516 | |
| 517 // Start dragging a panel. | |
| 518 // We have: P1* P4 P3 P2 | |
| 519 gfx::Point mouse_location = panel1->GetBounds().origin(); | |
| 520 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 521 mouse_location.Offset(-500, -5); | |
| 522 panel1_testing->DragTitlebar(mouse_location); | |
| 523 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 524 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 525 | |
| 526 ASSERT_EQ(4, docked_strip->num_panels()); | |
| 527 panels = PanelManager::GetInstance()->panels(); | |
| 528 EXPECT_EQ(panel2, panels[0]); | |
| 529 EXPECT_EQ(panel3, panels[1]); | |
| 530 EXPECT_EQ(panel4, panels[2]); | |
| 531 EXPECT_EQ(panel1, panels[3]); | |
| 532 EXPECT_EQ(position1, panel2->GetBounds().origin()); | |
| 533 EXPECT_EQ(position2, panel3->GetBounds().origin()); | |
| 534 EXPECT_EQ(position3, panel4->GetBounds().origin()); | |
| 535 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 536 | |
| 537 // Closing another panel while dragging in progress will keep the dragging | |
| 538 // panel intact. | |
| 539 // We have: P1* P4 P3 | |
| 540 CloseWindowAndWait(panel2); | |
| 541 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 542 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 543 | |
| 544 ASSERT_EQ(3, docked_strip->num_panels()); | |
| 545 panels = PanelManager::GetInstance()->panels(); | |
| 546 EXPECT_EQ(panel3, panels[0]); | |
| 547 EXPECT_EQ(panel4, panels[1]); | |
| 548 EXPECT_EQ(panel1, panels[2]); | |
| 549 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 550 EXPECT_EQ(position2, panel4->GetBounds().origin()); | |
| 551 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 552 | |
| 553 // Cancel the drag. | |
| 554 // We have: P4 P3 P1 | |
| 555 panel1_testing->CancelDragTitlebar(); | |
| 556 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 557 | |
| 558 ASSERT_EQ(3, docked_strip->num_panels()); | |
| 559 panels = PanelManager::GetInstance()->panels(); | |
| 560 EXPECT_EQ(panel1, panels[0]); | |
| 561 EXPECT_EQ(panel3, panels[1]); | |
| 562 EXPECT_EQ(panel4, panels[2]); | |
| 563 EXPECT_EQ(position1, panel1->GetBounds().origin()); | |
| 564 EXPECT_EQ(position2, panel3->GetBounds().origin()); | |
| 565 EXPECT_EQ(position3, panel4->GetBounds().origin()); | |
| 566 } | |
| 567 | |
| 568 // Test the scenario: drag a panel, close another panel, end the drag. | |
| 569 { | |
| 570 std::vector<Panel*> panels; | |
| 571 gfx::Point panel1_new_position = position1; | |
| 572 panel1_new_position.Offset(-500, 0); | |
| 573 | |
| 574 // Start dragging a panel. | |
| 575 // We have: P1* P4 P3 | |
| 576 gfx::Point mouse_location = panel1->GetBounds().origin(); | |
| 577 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 578 mouse_location.Offset(-500, -5); | |
| 579 panel1_testing->DragTitlebar(mouse_location); | |
| 580 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 581 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 582 | |
| 583 ASSERT_EQ(3, docked_strip->num_panels()); | |
| 584 panels = PanelManager::GetInstance()->panels(); | |
| 585 EXPECT_EQ(panel3, panels[0]); | |
| 586 EXPECT_EQ(panel4, panels[1]); | |
| 587 EXPECT_EQ(panel1, panels[2]); | |
| 588 EXPECT_EQ(position1, panel3->GetBounds().origin()); | |
| 589 EXPECT_EQ(position2, panel4->GetBounds().origin()); | |
| 590 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 591 | |
| 592 // Closing another panel while dragging in progress will keep the dragging | |
| 593 // panel intact. | |
| 594 // We have: P1* P4 | |
| 595 CloseWindowAndWait(panel3); | |
| 596 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 597 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 598 | |
| 599 ASSERT_EQ(2, docked_strip->num_panels()); | |
| 600 panels = PanelManager::GetInstance()->panels(); | |
| 601 EXPECT_EQ(panel4, panels[0]); | |
| 602 EXPECT_EQ(panel1, panels[1]); | |
| 603 EXPECT_EQ(position1, panel4->GetBounds().origin()); | |
| 604 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 605 | |
| 606 // Finish the drag. | |
| 607 // We have: P1 P4 | |
| 608 panel1_testing->FinishDragTitlebar(); | |
| 609 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 610 | |
| 611 ASSERT_EQ(2, docked_strip->num_panels()); | |
| 612 panels = PanelManager::GetInstance()->panels(); | |
| 613 EXPECT_EQ(panel4, panels[0]); | |
| 614 EXPECT_EQ(panel1, panels[1]); | |
| 615 EXPECT_EQ(position1, panel4->GetBounds().origin()); | |
| 616 EXPECT_EQ(position2, panel1->GetBounds().origin()); | |
| 617 } | |
| 618 | |
| 619 // Test the scenario: drag a panel and close the dragging panel. | |
| 620 { | |
| 621 std::vector<Panel*> panels; | |
| 622 gfx::Point panel1_new_position = position2; | |
| 623 panel1_new_position.Offset(-500, 0); | |
| 624 | |
| 625 // Start dragging a panel again. | |
| 626 // We have: P1* P4 | |
| 627 gfx::Point mouse_location = panel1->GetBounds().origin(); | |
| 628 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 629 mouse_location.Offset(-500, -5); | |
| 630 panel1_testing->DragTitlebar(mouse_location); | |
| 631 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 632 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 633 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 634 | |
| 635 ASSERT_EQ(2, docked_strip->num_panels()); | |
| 636 panels = PanelManager::GetInstance()->panels(); | |
| 637 EXPECT_EQ(panel4, panels[0]); | |
| 638 EXPECT_EQ(panel1, panels[1]); | |
| 639 EXPECT_EQ(position1, panel4->GetBounds().origin()); | |
| 640 | |
| 641 // Closing the dragging panel should end the drag. | |
| 642 // We have: P4 | |
| 643 CloseWindowAndWait(panel1); | |
| 644 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 645 | |
| 646 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 647 panels = PanelManager::GetInstance()->panels(); | |
| 648 EXPECT_EQ(panel4, panels[0]); | |
| 649 EXPECT_EQ(position1, panel4->GetBounds().origin()); | |
| 650 } | |
| 651 | |
| 652 panel_manager->CloseAll(); | |
| 653 } | |
| 654 | |
| 655 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragOneDetachedPanel) { | |
| 656 Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200)); | |
| 657 | |
| 658 // Test that the detached panel can be dragged almost anywhere except getting | |
| 659 // close to the bottom of the docked area to trigger the attach. | |
| 660 scoped_ptr<NativePanelTesting> panel_testing( | |
| 661 CreateNativePanelTesting(panel)); | |
| 662 gfx::Point origin = panel->GetBounds().origin(); | |
| 663 | |
| 664 panel_testing->PressLeftMouseButtonTitlebar(origin); | |
| 665 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 666 | |
| 667 origin.Offset(-51, -102); | |
| 668 panel_testing->DragTitlebar(origin); | |
| 669 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 670 | |
| 671 origin.Offset(37, 45); | |
| 672 panel_testing->DragTitlebar(origin); | |
| 673 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 674 | |
| 675 panel_testing->FinishDragTitlebar(); | |
| 676 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 677 | |
| 678 // Test that cancelling the drag will return the panel the the original | |
| 679 // position. | |
| 680 gfx::Point original_position = panel->GetBounds().origin(); | |
| 681 origin = original_position; | |
| 682 | |
| 683 panel_testing->PressLeftMouseButtonTitlebar(origin); | |
| 684 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 685 | |
| 686 origin.Offset(-51, -102); | |
| 687 panel_testing->DragTitlebar(origin); | |
| 688 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 689 | |
| 690 origin.Offset(37, 45); | |
| 691 panel_testing->DragTitlebar(origin); | |
| 692 EXPECT_EQ(origin, panel->GetBounds().origin()); | |
| 693 | |
| 694 panel_testing->CancelDragTitlebar(); | |
| 695 WaitForBoundsAnimationFinished(panel); | |
| 696 EXPECT_EQ(original_position, panel->GetBounds().origin()); | |
| 697 | |
| 698 PanelManager::GetInstance()->CloseAll(); | |
| 699 } | |
| 700 | |
| 701 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, | |
| 702 DISABLED_CloseDetachedPanelOnDrag) { | |
| 703 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 704 PanelDragController* drag_controller = panel_manager->drag_controller(); | |
| 705 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 706 | |
| 707 // Create 4 detached panels. | |
| 708 Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(100, 200, 100, 100)); | |
| 709 Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(200, 210, 110, 110)); | |
| 710 Panel* panel3 = CreateDetachedPanel("3", gfx::Rect(300, 220, 120, 120)); | |
| 711 Panel* panel4 = CreateDetachedPanel("4", gfx::Rect(400, 230, 130, 130)); | |
| 712 ASSERT_EQ(4, detached_strip->num_panels()); | |
| 713 | |
| 714 scoped_ptr<NativePanelTesting> panel1_testing( | |
| 715 CreateNativePanelTesting(panel1)); | |
| 716 gfx::Point panel1_old_position = panel1->GetBounds().origin(); | |
| 717 gfx::Point panel2_position = panel2->GetBounds().origin(); | |
| 718 gfx::Point panel3_position = panel3->GetBounds().origin(); | |
| 719 gfx::Point panel4_position = panel4->GetBounds().origin(); | |
| 720 | |
| 721 // Test the scenario: drag a panel, close another panel, cancel the drag. | |
| 722 { | |
| 723 gfx::Point panel1_new_position = panel1_old_position; | |
| 724 panel1_new_position.Offset(-51, -102); | |
| 725 | |
| 726 // Start dragging a panel. | |
| 727 panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); | |
| 728 panel1_testing->DragTitlebar(panel1_new_position); | |
| 729 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 730 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 731 | |
| 732 ASSERT_EQ(4, detached_strip->num_panels()); | |
| 733 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 734 EXPECT_TRUE(detached_strip->HasPanel(panel2)); | |
| 735 EXPECT_TRUE(detached_strip->HasPanel(panel3)); | |
| 736 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 737 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 738 EXPECT_EQ(panel2_position, panel2->GetBounds().origin()); | |
| 739 EXPECT_EQ(panel3_position, panel3->GetBounds().origin()); | |
| 740 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 741 | |
| 742 // Closing another panel while dragging in progress will keep the dragging | |
| 743 // panel intact. | |
| 744 CloseWindowAndWait(panel2); | |
| 745 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 746 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 747 | |
| 748 ASSERT_EQ(3, detached_strip->num_panels()); | |
| 749 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 750 EXPECT_TRUE(detached_strip->HasPanel(panel3)); | |
| 751 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 752 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 753 EXPECT_EQ(panel3_position, panel3->GetBounds().origin()); | |
| 754 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 755 | |
| 756 // Cancel the drag. | |
| 757 panel1_testing->CancelDragTitlebar(); | |
| 758 WaitForBoundsAnimationFinished(panel1); | |
| 759 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 760 | |
| 761 ASSERT_EQ(3, detached_strip->num_panels()); | |
| 762 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 763 EXPECT_TRUE(detached_strip->HasPanel(panel3)); | |
| 764 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 765 EXPECT_EQ(panel1_old_position, panel1->GetBounds().origin()); | |
| 766 EXPECT_EQ(panel3_position, panel3->GetBounds().origin()); | |
| 767 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 768 } | |
| 769 | |
| 770 // Test the scenario: drag a panel, close another panel, end the drag. | |
| 771 { | |
| 772 gfx::Point panel1_new_position = panel1_old_position; | |
| 773 panel1_new_position.Offset(-51, -102); | |
| 774 | |
| 775 // Start dragging a panel. | |
| 776 panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); | |
| 777 panel1_testing->DragTitlebar(panel1_new_position); | |
| 778 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 779 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 780 | |
| 781 ASSERT_EQ(3, detached_strip->num_panels()); | |
| 782 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 783 EXPECT_TRUE(detached_strip->HasPanel(panel3)); | |
| 784 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 785 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 786 EXPECT_EQ(panel3_position, panel3->GetBounds().origin()); | |
| 787 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 788 | |
| 789 // Closing another panel while dragging in progress will keep the dragging | |
| 790 // panel intact. | |
| 791 CloseWindowAndWait(panel3); | |
| 792 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 793 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 794 | |
| 795 ASSERT_EQ(2, detached_strip->num_panels()); | |
| 796 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 797 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 798 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 799 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 800 | |
| 801 // Finish the drag. | |
| 802 panel1_testing->FinishDragTitlebar(); | |
| 803 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 804 | |
| 805 ASSERT_EQ(2, detached_strip->num_panels()); | |
| 806 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 807 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 808 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 809 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 810 } | |
| 811 | |
| 812 // Test the scenario: drag a panel and close the dragging panel. | |
| 813 { | |
| 814 gfx::Point panel1_new_position = panel1->GetBounds().origin(); | |
| 815 panel1_new_position.Offset(-51, -102); | |
| 816 | |
| 817 // Start dragging a panel again. | |
| 818 panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); | |
| 819 panel1_testing->DragTitlebar(panel1_new_position); | |
| 820 EXPECT_TRUE(drag_controller->IsDragging()); | |
| 821 EXPECT_EQ(panel1, drag_controller->dragging_panel()); | |
| 822 | |
| 823 ASSERT_EQ(2, detached_strip->num_panels()); | |
| 824 EXPECT_TRUE(detached_strip->HasPanel(panel1)); | |
| 825 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 826 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 827 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 828 | |
| 829 // Closing the dragging panel should end the drag. | |
| 830 CloseWindowAndWait(panel1); | |
| 831 EXPECT_FALSE(drag_controller->IsDragging()); | |
| 832 | |
| 833 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 834 EXPECT_TRUE(detached_strip->HasPanel(panel4)); | |
| 835 EXPECT_EQ(panel4_position, panel4->GetBounds().origin()); | |
| 836 } | |
| 837 | |
| 838 panel_manager->CloseAll(); | |
| 839 } | |
| 840 | |
| 841 // http://crbug.com/133462 | |
| 842 #if defined(OS_LINUX) | |
| 843 #define MAYBE_Detach DISABLED_Detach | |
| 844 #else | |
| 845 #define MAYBE_Detach Detach | |
| 846 #endif | |
| 847 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, MAYBE_Detach) { | |
| 848 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 849 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 850 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 851 | |
| 852 // Create one docked panel. | |
| 853 Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 854 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 855 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 856 | |
| 857 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 858 | |
| 859 // Press on title-bar. | |
| 860 scoped_ptr<NativePanelTesting> panel_testing( | |
| 861 CreateNativePanelTesting(panel)); | |
| 862 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 863 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 864 | |
| 865 // Drag up the panel in a small offset that does not trigger the detach. | |
| 866 // Expect that the panel is still docked and only x coordinate of its position | |
| 867 // is changed. | |
| 868 gfx::Point drag_delta_to_remain_docked = GetDragDeltaToRemainDocked(); | |
| 869 mouse_location = mouse_location.Add(drag_delta_to_remain_docked); | |
| 870 panel_testing->DragTitlebar(mouse_location); | |
| 871 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 872 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 873 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 874 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 875 panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0); | |
| 876 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 877 | |
| 878 // Continue dragging up the panel in big offset that triggers the detach. | |
| 879 // Expect that the panel is previewed as detached. | |
| 880 gfx::Point drag_delta_to_detach = GetDragDeltaToDetach(); | |
| 881 mouse_location = mouse_location.Add(drag_delta_to_detach); | |
| 882 panel_testing->DragTitlebar(mouse_location); | |
| 883 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 884 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 885 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 886 panel_new_bounds.Offset( | |
| 887 drag_delta_to_detach.x(), | |
| 888 drag_delta_to_detach.y() + drag_delta_to_remain_docked.y()); | |
| 889 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 890 | |
| 891 // Finish the drag. | |
| 892 // Expect that the panel stays as detached. | |
| 893 panel_testing->FinishDragTitlebar(); | |
| 894 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 895 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 896 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 897 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 898 | |
| 899 panel_manager->CloseAll(); | |
| 900 } | |
| 901 | |
| 902 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DetachAndCancel) { | |
| 903 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 904 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 905 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 906 | |
| 907 // Create one docked panel. | |
| 908 Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 909 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 910 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 911 | |
| 912 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 913 | |
| 914 // Press on title-bar. | |
| 915 scoped_ptr<NativePanelTesting> panel_testing( | |
| 916 CreateNativePanelTesting(panel)); | |
| 917 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 918 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 919 | |
| 920 // Drag up the panel in a small offset that does not trigger the detach. | |
| 921 // Expect that the panel is still docked and only x coordinate of its position | |
| 922 // is changed. | |
| 923 gfx::Point drag_delta_to_remain_docked = GetDragDeltaToRemainDocked(); | |
| 924 mouse_location = mouse_location.Add(drag_delta_to_remain_docked); | |
| 925 panel_testing->DragTitlebar(mouse_location); | |
| 926 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 927 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 928 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 929 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 930 panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0); | |
| 931 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 932 | |
| 933 // Continue dragging up the panel in big offset that triggers the detach. | |
| 934 // Expect that the panel is previewed as detached. | |
| 935 gfx::Point drag_delta_to_detach = GetDragDeltaToDetach(); | |
| 936 mouse_location = mouse_location.Add(drag_delta_to_detach); | |
| 937 panel_testing->DragTitlebar(mouse_location); | |
| 938 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 939 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 940 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 941 panel_new_bounds.Offset( | |
| 942 drag_delta_to_detach.x(), | |
| 943 drag_delta_to_detach.y() + drag_delta_to_remain_docked.y()); | |
| 944 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 945 | |
| 946 // Cancel the drag. | |
| 947 // Expect that the panel is back as docked. | |
| 948 panel_testing->CancelDragTitlebar(); | |
| 949 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 950 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 951 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 952 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 953 | |
| 954 panel_manager->CloseAll(); | |
| 955 } | |
| 956 | |
| 957 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, Attach) { | |
| 958 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 959 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 960 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 961 | |
| 962 // Create one detached panel. | |
| 963 Panel* panel = CreateDetachedPanel("1", gfx::Rect(400, 300, 100, 100)); | |
| 964 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 965 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 966 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 967 | |
| 968 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 969 | |
| 970 // Press on title-bar. | |
| 971 scoped_ptr<NativePanelTesting> panel_testing( | |
| 972 CreateNativePanelTesting(panel)); | |
| 973 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 974 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 975 | |
| 976 // Drag down the panel but not close enough to the bottom of work area. | |
| 977 // Expect that the panel is still detached. | |
| 978 gfx::Point drag_delta_to_remain_detached = | |
| 979 GetDragDeltaToRemainDetached(panel); | |
| 980 mouse_location = mouse_location.Add(drag_delta_to_remain_detached); | |
| 981 panel_testing->DragTitlebar(mouse_location); | |
| 982 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 983 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 984 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 985 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 986 panel_new_bounds.Offset(drag_delta_to_remain_detached); | |
| 987 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 988 | |
| 989 // Continue dragging down the panel to make it close enough to the bottom of | |
| 990 // work area. | |
| 991 // Expect that the panel is previewed as docked. | |
| 992 gfx::Point drag_delta_to_attach = GetDragDeltaToAttach(panel); | |
| 993 mouse_location = mouse_location.Add(drag_delta_to_attach); | |
| 994 panel_testing->DragTitlebar(mouse_location); | |
| 995 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 996 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 997 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 998 panel_new_bounds.Offset(drag_delta_to_attach); | |
| 999 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1000 | |
| 1001 // Finish the drag. | |
| 1002 // Expect that the panel stays as docked and moves to the final position. | |
| 1003 panel_testing->FinishDragTitlebar(); | |
| 1004 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 1005 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1006 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 1007 panel_new_bounds.set_x( | |
| 1008 docked_strip->StartingRightPosition() - panel_new_bounds.width()); | |
| 1009 panel_new_bounds.set_y( | |
| 1010 docked_strip->display_area().bottom() - panel_new_bounds.height()); | |
| 1011 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1012 | |
| 1013 panel_manager->CloseAll(); | |
| 1014 } | |
| 1015 | |
| 1016 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, AttachAndCancel) { | |
| 1017 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 1018 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 1019 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 1020 | |
| 1021 // Create one detached panel. | |
| 1022 Panel* panel = CreateDetachedPanel("1", gfx::Rect(400, 300, 100, 100)); | |
| 1023 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 1024 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1025 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1026 | |
| 1027 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 1028 | |
| 1029 // Press on title-bar. | |
| 1030 scoped_ptr<NativePanelTesting> panel_testing( | |
| 1031 CreateNativePanelTesting(panel)); | |
| 1032 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 1033 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 1034 | |
| 1035 // Drag down the panel but not close enough to the bottom of work area. | |
| 1036 // Expect that the panel is still detached. | |
| 1037 gfx::Point drag_delta_to_remain_detached = | |
| 1038 GetDragDeltaToRemainDetached(panel); | |
| 1039 mouse_location = mouse_location.Add(drag_delta_to_remain_detached); | |
| 1040 panel_testing->DragTitlebar(mouse_location); | |
| 1041 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 1042 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1043 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1044 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 1045 panel_new_bounds.Offset(drag_delta_to_remain_detached); | |
| 1046 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1047 | |
| 1048 // Continue dragging down the panel to make it close enough to the bottom of | |
| 1049 // work area. | |
| 1050 // Expect that the panel is previewed as docked. | |
| 1051 gfx::Point drag_delta_to_attach = GetDragDeltaToAttach(panel); | |
| 1052 mouse_location = mouse_location.Add(drag_delta_to_attach); | |
| 1053 panel_testing->DragTitlebar(mouse_location); | |
| 1054 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 1055 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1056 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 1057 panel_new_bounds.Offset(drag_delta_to_attach); | |
| 1058 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1059 | |
| 1060 // Cancel the drag. | |
| 1061 // Expect that the panel is back as detached. | |
| 1062 panel_testing->CancelDragTitlebar(); | |
| 1063 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 1064 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1065 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1066 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 1067 | |
| 1068 panel_manager->CloseAll(); | |
| 1069 } | |
| 1070 | |
| 1071 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DetachAttachAndCancel) { | |
| 1072 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 1073 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 1074 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 1075 | |
| 1076 // Create one docked panel. | |
| 1077 Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); | |
| 1078 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 1079 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1080 | |
| 1081 gfx::Rect panel_old_bounds = panel->GetBounds(); | |
| 1082 | |
| 1083 // Press on title-bar. | |
| 1084 scoped_ptr<NativePanelTesting> panel_testing( | |
| 1085 CreateNativePanelTesting(panel)); | |
| 1086 gfx::Point mouse_location(panel->GetBounds().origin()); | |
| 1087 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); | |
| 1088 | |
| 1089 // Drag up the panel to trigger the detach. | |
| 1090 // Expect that the panel is previewed as detached. | |
| 1091 gfx::Point drag_delta_to_detach = GetDragDeltaToDetach(); | |
| 1092 mouse_location = mouse_location.Add(drag_delta_to_detach); | |
| 1093 panel_testing->DragTitlebar(mouse_location); | |
| 1094 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 1095 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1096 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1097 gfx::Rect panel_new_bounds = panel_old_bounds; | |
| 1098 panel_new_bounds.Offset(drag_delta_to_detach); | |
| 1099 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1100 | |
| 1101 // Continue dragging down the panel to trigger the re-attach. | |
| 1102 gfx::Point drag_delta_to_reattach = GetDragDeltaToAttach(panel); | |
| 1103 mouse_location = mouse_location.Add(drag_delta_to_reattach); | |
| 1104 panel_testing->DragTitlebar(mouse_location); | |
| 1105 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 1106 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1107 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 1108 panel_new_bounds.Offset(drag_delta_to_reattach); | |
| 1109 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1110 | |
| 1111 // Continue dragging up the panel to trigger the detach again. | |
| 1112 gfx::Point drag_delta_to_detach_again = GetDragDeltaToDetach(); | |
| 1113 mouse_location = mouse_location.Add(drag_delta_to_detach_again); | |
| 1114 panel_testing->DragTitlebar(mouse_location); | |
| 1115 ASSERT_EQ(0, docked_strip->num_panels()); | |
| 1116 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1117 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1118 panel_new_bounds.Offset(drag_delta_to_detach_again); | |
| 1119 EXPECT_EQ(panel_new_bounds, panel->GetBounds()); | |
| 1120 | |
| 1121 // Cancel the drag. | |
| 1122 // Expect that the panel stays as docked. | |
| 1123 panel_testing->CancelDragTitlebar(); | |
| 1124 ASSERT_EQ(1, docked_strip->num_panels()); | |
| 1125 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1126 EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type()); | |
| 1127 EXPECT_EQ(panel_old_bounds, panel->GetBounds()); | |
| 1128 | |
| 1129 panel_manager->CloseAll(); | |
| 1130 } | |
| 1131 | |
| 1132 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DetachWithSqueeze) { | |
| 1133 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 1134 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 1135 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 1136 | |
| 1137 gfx::Point drag_delta_to_detach = GetDragDeltaToDetach(); | |
| 1138 | |
| 1139 // Create some docked panels. | |
| 1140 // docked: P1 P2 P3 P4 P5 | |
| 1141 Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 200, 100)); | |
| 1142 Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 200, 100)); | |
| 1143 Panel* panel3 = CreateDockedPanel("3", gfx::Rect(0, 0, 200, 100)); | |
| 1144 Panel* panel4 = CreateDockedPanel("4", gfx::Rect(0, 0, 200, 100)); | |
| 1145 Panel* panel5 = CreateDockedPanel("5", gfx::Rect(0, 0, 200, 100)); | |
| 1146 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1147 ASSERT_EQ(5, docked_strip->num_panels()); | |
| 1148 | |
| 1149 // Drag to detach the middle docked panel. | |
| 1150 // Expect to have: | |
| 1151 // detached: P2 | |
| 1152 // docked: P1 P3 P4 P5 | |
| 1153 gfx::Point panel2_docked_position = panel2->GetBounds().origin(); | |
| 1154 DragPanelByDelta(panel2, drag_delta_to_detach); | |
| 1155 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1156 ASSERT_EQ(4, docked_strip->num_panels()); | |
| 1157 EXPECT_EQ(PanelStrip::DOCKED, panel1->panel_strip()->type()); | |
| 1158 EXPECT_EQ(PanelStrip::DETACHED, panel2->panel_strip()->type()); | |
| 1159 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1160 EXPECT_EQ(PanelStrip::DOCKED, panel4->panel_strip()->type()); | |
| 1161 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1162 gfx::Point panel2_new_position = | |
| 1163 panel2_docked_position.Add(drag_delta_to_detach); | |
| 1164 EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); | |
| 1165 | |
| 1166 // Drag to detach the left-most docked panel. | |
| 1167 // Expect to have: | |
| 1168 // detached: P2 P4 | |
| 1169 // docked: P1 P3 P5 | |
| 1170 gfx::Point panel4_docked_position = panel4->GetBounds().origin(); | |
| 1171 DragPanelByDelta(panel4, drag_delta_to_detach); | |
| 1172 ASSERT_EQ(2, detached_strip->num_panels()); | |
| 1173 ASSERT_EQ(3, docked_strip->num_panels()); | |
| 1174 EXPECT_EQ(PanelStrip::DOCKED, panel1->panel_strip()->type()); | |
| 1175 EXPECT_EQ(PanelStrip::DETACHED, panel2->panel_strip()->type()); | |
| 1176 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1177 EXPECT_EQ(PanelStrip::DETACHED, panel4->panel_strip()->type()); | |
| 1178 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1179 EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); | |
| 1180 gfx::Point panel4_new_position = | |
| 1181 panel4_docked_position.Add(drag_delta_to_detach); | |
| 1182 EXPECT_EQ(panel4_new_position, panel4->GetBounds().origin()); | |
| 1183 | |
| 1184 // Drag to detach the right-most docked panel. | |
| 1185 // Expect to have: | |
| 1186 // detached: P1 P2 P4 | |
| 1187 // docked: P3 P5 | |
| 1188 gfx::Point docked_position1 = panel1->GetBounds().origin(); | |
| 1189 gfx::Point docked_position2 = panel3->GetBounds().origin(); | |
| 1190 | |
| 1191 DragPanelByDelta(panel1, drag_delta_to_detach); | |
| 1192 ASSERT_EQ(3, detached_strip->num_panels()); | |
| 1193 ASSERT_EQ(2, docked_strip->num_panels()); | |
| 1194 EXPECT_EQ(PanelStrip::DETACHED, panel1->panel_strip()->type()); | |
| 1195 EXPECT_EQ(PanelStrip::DETACHED, panel2->panel_strip()->type()); | |
| 1196 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1197 EXPECT_EQ(PanelStrip::DETACHED, panel4->panel_strip()->type()); | |
| 1198 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1199 gfx::Point panel1_new_position = docked_position1.Add(drag_delta_to_detach); | |
| 1200 EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); | |
| 1201 EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); | |
| 1202 EXPECT_EQ(panel4_new_position, panel4->GetBounds().origin()); | |
| 1203 | |
| 1204 // No more squeeze, docked panels should stay put. | |
| 1205 EXPECT_EQ(docked_position1, panel3->GetBounds().origin()); | |
| 1206 EXPECT_EQ(panel1->GetBounds().width(), panel1->GetRestoredBounds().width()); | |
| 1207 EXPECT_EQ(docked_position2, panel5->GetBounds().origin()); | |
| 1208 EXPECT_EQ(panel2->GetBounds().width(), panel2->GetRestoredBounds().width()); | |
| 1209 | |
| 1210 panel_manager->CloseAll(); | |
| 1211 } | |
| 1212 | |
| 1213 // Flaky (sometimes timeout): http://crbug.com/141156 | |
| 1214 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DISABLED_AttachWithSqueeze) { | |
| 1215 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 1216 DockedPanelStrip* docked_strip = panel_manager->docked_strip(); | |
| 1217 DetachedPanelStrip* detached_strip = panel_manager->detached_strip(); | |
| 1218 | |
| 1219 // Create some detached, docked panels. | |
| 1220 // detached: P1 P2 P3 | |
| 1221 // docked: P4 P5 P6 P7 | |
| 1222 Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(100, 300, 200, 100)); | |
| 1223 Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(200, 300, 200, 100)); | |
| 1224 Panel* panel3 = CreateDetachedPanel("3", gfx::Rect(400, 300, 200, 100)); | |
| 1225 Panel* panel4 = CreateDockedPanel("4", gfx::Rect(0, 0, 200, 100)); | |
| 1226 Panel* panel5 = CreateDockedPanel("5", gfx::Rect(0, 0, 200, 100)); | |
| 1227 Panel* panel6 = CreateDockedPanel("6", gfx::Rect(0, 0, 200, 100)); | |
| 1228 Panel* panel7 = CreateDockedPanel("7", gfx::Rect(0, 0, 200, 100)); | |
| 1229 ASSERT_EQ(3, detached_strip->num_panels()); | |
| 1230 ASSERT_EQ(4, docked_strip->num_panels()); | |
| 1231 | |
| 1232 gfx::Point detached_position1 = panel1->GetBounds().origin(); | |
| 1233 gfx::Point detached_position2 = panel2->GetBounds().origin(); | |
| 1234 gfx::Point detached_position3 = panel3->GetBounds().origin(); | |
| 1235 gfx::Point docked_position4 = panel4->GetBounds().origin(); | |
| 1236 gfx::Point docked_position5 = panel5->GetBounds().origin(); | |
| 1237 gfx::Point docked_position6 = panel6->GetBounds().origin(); | |
| 1238 gfx::Point docked_position7 = panel7->GetBounds().origin(); | |
| 1239 | |
| 1240 // Drag to attach a detached panel between 2 docked panels. | |
| 1241 // Expect to have: | |
| 1242 // detached: P1 P2 | |
| 1243 // docked: P4 P3 P5 P6 P7 | |
| 1244 gfx::Point drag_to_location(panel5->GetBounds().x() + 10, | |
| 1245 panel5->GetBounds().y()); | |
| 1246 DragPanelToMouseLocation(panel3, drag_to_location); | |
| 1247 ASSERT_EQ(2, detached_strip->num_panels()); | |
| 1248 ASSERT_EQ(5, docked_strip->num_panels()); | |
| 1249 EXPECT_EQ(PanelStrip::DETACHED, panel1->panel_strip()->type()); | |
| 1250 EXPECT_EQ(PanelStrip::DETACHED, panel2->panel_strip()->type()); | |
| 1251 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1252 EXPECT_EQ(PanelStrip::DOCKED, panel4->panel_strip()->type()); | |
| 1253 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1254 EXPECT_EQ(PanelStrip::DOCKED, panel6->panel_strip()->type()); | |
| 1255 EXPECT_EQ(PanelStrip::DOCKED, panel7->panel_strip()->type()); | |
| 1256 EXPECT_EQ(detached_position1, panel1->GetBounds().origin()); | |
| 1257 EXPECT_EQ(detached_position2, panel2->GetBounds().origin()); | |
| 1258 | |
| 1259 // Wait for active states to settle. | |
| 1260 MessageLoopForUI::current()->RunAllPending(); | |
| 1261 | |
| 1262 // Panel positions should have shifted because of the "squeeze" mode. | |
| 1263 EXPECT_NE(docked_position4, panel4->GetBounds().origin()); | |
| 1264 EXPECT_LT(panel4->GetBounds().width(), panel4->GetRestoredBounds().width()); | |
| 1265 EXPECT_NE(docked_position5, panel5->GetBounds().origin()); | |
| 1266 EXPECT_LT(panel5->GetBounds().width(), panel5->GetRestoredBounds().width()); | |
| 1267 | |
| 1268 #if defined(OS_WIN) | |
| 1269 // The panel we dragged becomes the active one. | |
| 1270 EXPECT_EQ(true, panel3->IsActive()); | |
| 1271 EXPECT_EQ(panel3->GetBounds().width(), panel3->GetRestoredBounds().width()); | |
| 1272 | |
| 1273 EXPECT_NE(docked_position6, panel6->GetBounds().origin()); | |
| 1274 #else | |
| 1275 // The last panel is active so these positions do not change. | |
| 1276 // TODO (ABurago) this is wrong behavior, a panel should activate | |
| 1277 // when it is dragged. Change the test when the behavior is fixed. | |
| 1278 EXPECT_EQ(true, panel7->IsActive()); | |
| 1279 EXPECT_EQ(panel7->GetBounds().width(), panel7->GetRestoredBounds().width()); | |
| 1280 | |
| 1281 EXPECT_EQ(docked_position6, panel6->GetBounds().origin()); | |
| 1282 #endif | |
| 1283 EXPECT_EQ(docked_position7, panel7->GetBounds().origin()); | |
| 1284 | |
| 1285 // Drag to attach a detached panel to most-right. | |
| 1286 // Expect to have: | |
| 1287 // detached: P1 | |
| 1288 // docked: P2 P4 P3 P5 P6 P7 | |
| 1289 gfx::Point drag_to_location2(panel4->GetBounds().right() + 10, | |
| 1290 panel4->GetBounds().y()); | |
| 1291 DragPanelToMouseLocation(panel2, drag_to_location2); | |
| 1292 ASSERT_EQ(1, detached_strip->num_panels()); | |
| 1293 ASSERT_EQ(6, docked_strip->num_panels()); | |
| 1294 EXPECT_EQ(PanelStrip::DETACHED, panel1->panel_strip()->type()); | |
| 1295 EXPECT_EQ(PanelStrip::DOCKED, panel2->panel_strip()->type()); | |
| 1296 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1297 EXPECT_EQ(PanelStrip::DOCKED, panel4->panel_strip()->type()); | |
| 1298 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1299 EXPECT_EQ(PanelStrip::DOCKED, panel6->panel_strip()->type()); | |
| 1300 EXPECT_EQ(PanelStrip::DOCKED, panel7->panel_strip()->type()); | |
| 1301 EXPECT_EQ(detached_position1, panel1->GetBounds().origin()); | |
| 1302 | |
| 1303 // Drag to attach a detached panel to most-left. | |
| 1304 // Expect to have: | |
| 1305 // docked: P2 P4 P1 P3 P5 P6 P7 | |
| 1306 gfx::Point drag_to_location3(panel3->GetBounds().x() - 10, | |
| 1307 panel3->GetBounds().y()); | |
| 1308 DragPanelToMouseLocation(panel1, drag_to_location3); | |
| 1309 ASSERT_EQ(0, detached_strip->num_panels()); | |
| 1310 ASSERT_EQ(7, docked_strip->num_panels()); | |
| 1311 EXPECT_EQ(PanelStrip::DOCKED, panel1->panel_strip()->type()); | |
| 1312 EXPECT_EQ(PanelStrip::DOCKED, panel2->panel_strip()->type()); | |
| 1313 EXPECT_EQ(PanelStrip::DOCKED, panel3->panel_strip()->type()); | |
| 1314 EXPECT_EQ(PanelStrip::DOCKED, panel4->panel_strip()->type()); | |
| 1315 EXPECT_EQ(PanelStrip::DOCKED, panel5->panel_strip()->type()); | |
| 1316 EXPECT_EQ(PanelStrip::DOCKED, panel6->panel_strip()->type()); | |
| 1317 EXPECT_EQ(PanelStrip::DOCKED, panel7->panel_strip()->type()); | |
| 1318 | |
| 1319 panel_manager->CloseAll(); | |
| 1320 } | |
| 1321 | |
| 1322 IN_PROC_BROWSER_TEST_F(OldPanelDragBrowserTest, DragDetachedPanelToTop) { | |
| 1323 // Setup the test areas to have top-aligned bar excluded from work area. | |
| 1324 const gfx::Rect primary_screen_area(0, 0, 800, 600); | |
| 1325 const gfx::Rect work_area(0, 10, 800, 590); | |
| 1326 SetTestingAreas(primary_screen_area, work_area); | |
| 1327 | |
| 1328 PanelManager* panel_manager = PanelManager::GetInstance(); | |
| 1329 Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200)); | |
| 1330 | |
| 1331 // Drag up the panel. Expect that the panel should not go outside the top of | |
| 1332 // the work area. | |
| 1333 gfx::Point drag_to_location(250, 0); | |
| 1334 DragPanelToMouseLocation(panel, drag_to_location); | |
| 1335 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1336 EXPECT_EQ(drag_to_location.x(), panel->GetBounds().origin().x()); | |
| 1337 EXPECT_EQ(work_area.y(), panel->GetBounds().origin().y()); | |
| 1338 | |
| 1339 // Drag down the panel. Expect that the panel can be dragged without | |
| 1340 // constraint. | |
| 1341 drag_to_location = gfx::Point(280, 150); | |
| 1342 DragPanelToMouseLocation(panel, drag_to_location); | |
| 1343 EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type()); | |
| 1344 EXPECT_EQ(drag_to_location, panel->GetBounds().origin()); | |
| 1345 | |
| 1346 panel_manager->CloseAll(); | |
| 1347 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10908153:
[Panel refactor] Deprecate old panels. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src