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/bind.h" 6 #include "base/prefs/pref_service.h" 7 #include "base/strings/utf_string_conversions.h" 8 #include "chrome/app/chrome_command_ids.h" 9 #include "chrome/browser/chrome_notification_types.h" 10 #include "chrome/browser/devtools/devtools_window.h" 11 #include "chrome/browser/extensions/extension_apitest.h" 12 #include "chrome/browser/net/url_request_mock_util.h" 13 #include "chrome/browser/prefs/browser_prefs.h" 14 #include "chrome/browser/profiles/profile.h" 15 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h" 16 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h" 17 #include "chrome/browser/ui/browser.h" 18 #include "chrome/browser/ui/browser_commands.h" 19 #include "chrome/browser/ui/browser_finder.h" 20 #include "chrome/browser/ui/browser_iterator.h" 21 #include "chrome/browser/ui/browser_window.h" 22 #include "chrome/browser/ui/panels/base_panel_browser_test.h" 23 #include "chrome/browser/ui/panels/docked_panel_collection.h" 24 #include "chrome/browser/ui/panels/native_panel.h" 25 #include "chrome/browser/ui/panels/panel.h" 26 #include "chrome/browser/ui/panels/panel_manager.h" 27 #include "chrome/browser/ui/panels/test_panel_active_state_observer.h" 28 #include "chrome/browser/web_applications/web_app.h" 29 #include "chrome/common/chrome_switches.h" 30 #include "chrome/common/pref_names.h" 31 #include "chrome/common/url_constants.h" 32 #include "chrome/test/base/interactive_test_utils.h" 33 #include "chrome/test/base/ui_test_utils.h" 34 #include "content/public/browser/native_web_keyboard_event.h" 35 #include "content/public/browser/notification_service.h" 36 #include "content/public/browser/web_contents.h" 37 #include "content/public/common/url_constants.h" 38 #include "content/public/test/browser_test_utils.h" 39 #include "extensions/browser/extension_registry.h" 40 #include "extensions/common/constants.h" 41 #include "net/base/net_util.h" 42 #include "net/test/url_request/url_request_mock_http_job.h" 43 #include "testing/gtest/include/gtest/gtest.h" 44 #include "ui/base/hit_test.h" 45 #include "ui/events/event_utils.h" 46 #include "ui/gfx/screen.h" 47 48 using content::WebContents; 49 50 class PanelBrowserTest : public BasePanelBrowserTest { 51 public: 52 PanelBrowserTest() : BasePanelBrowserTest() { 53 } 54 55 protected: 56 // Helper function for debugging. 57 void PrintAllPanelBounds() { 58 const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels(); 59 DLOG(WARNING) << "PanelBounds:"; 60 for (size_t i = 0; i < panels.size(); ++i) { 61 DLOG(WARNING) << "#=" << i 62 << ", ptr=" << panels[i] 63 << ", x=" << panels[i]->GetBounds().x() 64 << ", y=" << panels[i]->GetBounds().y() 65 << ", width=" << panels[i]->GetBounds().width() 66 << ", height" << panels[i]->GetBounds().height(); 67 } 68 } 69 70 std::vector<gfx::Rect> GetAllPanelBounds() { 71 std::vector<Panel*> panels = PanelManager::GetInstance()->panels(); 72 std::vector<gfx::Rect> bounds; 73 for (size_t i = 0; i < panels.size(); i++) 74 bounds.push_back(panels[i]->GetBounds()); 75 return bounds; 76 } 77 78 std::vector<gfx::Rect> AddXDeltaToBounds(const std::vector<gfx::Rect>& bounds, 79 const std::vector<int>& delta_x) { 80 std::vector<gfx::Rect> new_bounds = bounds; 81 for (size_t i = 0; i < bounds.size(); ++i) 82 new_bounds[i].Offset(delta_x[i], 0); 83 return new_bounds; 84 } 85 86 std::vector<Panel::ExpansionState> GetAllPanelExpansionStates() { 87 std::vector<Panel*> panels = PanelManager::GetInstance()->panels(); 88 std::vector<Panel::ExpansionState> expansion_states; 89 for (size_t i = 0; i < panels.size(); i++) 90 expansion_states.push_back(panels[i]->expansion_state()); 91 return expansion_states; 92 } 93 94 std::vector<bool> GetAllPanelActiveStates() { 95 std::vector<Panel*> panels = PanelManager::GetInstance()->panels(); 96 std::vector<bool> active_states; 97 for (size_t i = 0; i < panels.size(); i++) 98 active_states.push_back(panels[i]->IsActive()); 99 return active_states; 100 } 101 102 std::vector<bool> ProduceExpectedActiveStates( 103 int expected_active_panel_index) { 104 std::vector<Panel*> panels = PanelManager::GetInstance()->panels(); 105 std::vector<bool> active_states; 106 for (int i = 0; i < static_cast<int>(panels.size()); i++) 107 active_states.push_back(i == expected_active_panel_index); 108 return active_states; 109 } 110 111 void WaitForPanelActiveStates(const std::vector<bool>& old_states, 112 const std::vector<bool>& new_states) { 113 DCHECK(old_states.size() == new_states.size()); 114 std::vector<Panel*> panels = PanelManager::GetInstance()->panels(); 115 for (size_t i = 0; i < old_states.size(); i++) { 116 if (old_states[i] != new_states[i]){ 117 WaitForPanelActiveState( 118 panels[i], new_states[i] ? SHOW_AS_ACTIVE : SHOW_AS_INACTIVE); 119 } 120 } 121 } 122 123 void TestMinimizeRestore() { 124 // This constant is used to generate a point 'sufficiently higher then 125 // top edge of the panel'. On some platforms (Mac) we extend hover area 126 // a bit above the minimized panel as well, so it takes significant 127 // distance to 'move mouse out' of the hover-sensitive area. 128 const int kFarEnoughFromHoverArea = 153; 129 130 PanelManager* panel_manager = PanelManager::GetInstance(); 131 std::vector<Panel*> panels = panel_manager->panels(); 132 std::vector<gfx::Rect> test_begin_bounds = GetAllPanelBounds(); 133 std::vector<gfx::Rect> expected_bounds = test_begin_bounds; 134 std::vector<Panel::ExpansionState> expected_expansion_states( 135 panels.size(), Panel::EXPANDED); 136 std::vector<NativePanelTesting*> native_panels_testing(panels.size()); 137 for (size_t i = 0; i < panels.size(); ++i) { 138 native_panels_testing[i] = CreateNativePanelTesting(panels[i]); 139 } 140 141 // Verify titlebar click does not minimize. 142 for (size_t index = 0; index < panels.size(); ++index) { 143 // Press left mouse button. Verify nothing changed. 144 native_panels_testing[index]->PressLeftMouseButtonTitlebar( 145 panels[index]->GetBounds().origin()); 146 EXPECT_EQ(expected_bounds, GetAllPanelBounds()); 147 EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates()); 148 149 // Release mouse button. Verify nothing changed. 150 native_panels_testing[index]->ReleaseMouseButtonTitlebar(); 151 EXPECT_EQ(expected_bounds, GetAllPanelBounds()); 152 EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates()); 153 } 154 155 // Minimize all panels for next stage in test. 156 for (size_t index = 0; index < panels.size(); ++index) { 157 panels[index]->Minimize(); 158 expected_bounds[index].set_height(panel::kMinimizedPanelHeight); 159 expected_bounds[index].set_y( 160 test_begin_bounds[index].y() + 161 test_begin_bounds[index].height() - panel::kMinimizedPanelHeight); 162 expected_expansion_states[index] = Panel::MINIMIZED; 163 EXPECT_EQ(expected_bounds, GetAllPanelBounds()); 164 EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates()); 165 } 166 167 // Setup bounds and expansion states for minimized and titlebar-only 168 // states. 169 std::vector<Panel::ExpansionState> titlebar_exposed_states( 170 panels.size(), Panel::TITLE_ONLY); 171 std::vector<gfx::Rect> minimized_bounds = expected_bounds; 172 std::vector<Panel::ExpansionState> minimized_states( 173 panels.size(), Panel::MINIMIZED); 174 std::vector<gfx::Rect> titlebar_exposed_bounds = test_begin_bounds; 175 for (size_t index = 0; index < panels.size(); ++index) { 176 titlebar_exposed_bounds[index].set_height( 177 panels[index]->native_panel()->TitleOnlyHeight()); 178 titlebar_exposed_bounds[index].set_y( 179 test_begin_bounds[index].y() + 180 test_begin_bounds[index].height() - 181 panels[index]->native_panel()->TitleOnlyHeight()); 182 } 183 184 // Test hover. All panels are currently in minimized state. 185 EXPECT_EQ(minimized_states, GetAllPanelExpansionStates()); 186 for (size_t index = 0; index < panels.size(); ++index) { 187 // Hover mouse on minimized panel. 188 // Verify titlebar is exposed on all panels. 189 gfx::Point hover_point(panels[index]->GetBounds().origin()); 190 MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point); 191 EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds()); 192 EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates()); 193 194 // Hover mouse above the panel. Verify all panels are minimized. 195 hover_point.set_y( 196 panels[index]->GetBounds().y() - kFarEnoughFromHoverArea); 197 MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point); 198 EXPECT_EQ(minimized_bounds, GetAllPanelBounds()); 199 EXPECT_EQ(minimized_states, GetAllPanelExpansionStates()); 200 201 // Hover mouse below minimized panel. 202 // Verify titlebar is exposed on all panels. 203 hover_point.set_y(panels[index]->GetBounds().y() + 204 panels[index]->GetBounds().height() + 5); 205 MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point); 206 EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds()); 207 EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates()); 208 209 // Hover below titlebar exposed panel. Verify nothing changed. 210 hover_point.set_y(panels[index]->GetBounds().y() + 211 panels[index]->GetBounds().height() + 6); 212 MoveMouse(hover_point); 213 EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds()); 214 EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates()); 215 216 // Hover mouse above panel. Verify all panels are minimized. 217 hover_point.set_y( 218 panels[index]->GetBounds().y() - kFarEnoughFromHoverArea); 219 MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point); 220 EXPECT_EQ(minimized_bounds, GetAllPanelBounds()); 221 EXPECT_EQ(minimized_states, GetAllPanelExpansionStates()); 222 } 223 224 // Test restore. All panels are currently in minimized state. 225 for (size_t index = 0; index < panels.size(); ++index) { 226 // Hover on the last panel. This is to test the case of clicking on the 227 // panel when it's in titlebar exposed state. 228 if (index == panels.size() - 1) 229 MoveMouse(minimized_bounds[index].origin()); 230 231 // Click minimized or title bar exposed panel as the case may be. 232 // Verify panel is restored to its original size. 233 native_panels_testing[index]->PressLeftMouseButtonTitlebar( 234 panels[index]->GetBounds().origin()); 235 native_panels_testing[index]->ReleaseMouseButtonTitlebar(); 236 expected_bounds[index].set_height( 237 test_begin_bounds[index].height()); 238 expected_bounds[index].set_y(test_begin_bounds[index].y()); 239 expected_expansion_states[index] = Panel::EXPANDED; 240 EXPECT_EQ(expected_bounds, GetAllPanelBounds()); 241 EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates()); 242 243 // Hover again on the last panel which is now restored, to reset the 244 // titlebar exposed state. 245 if (index == panels.size() - 1) 246 MoveMouse(minimized_bounds[index].origin()); 247 } 248 249 // The below could be separate tests, just adding a TODO here for tracking. 250 // TODO(prasadt): Add test for dragging when in titlebar exposed state. 251 // TODO(prasadt): Add test in presence of auto hiding task bar. 252 253 for (size_t i = 0; i < panels.size(); ++i) 254 delete native_panels_testing[i]; 255 } 256 }; 257 258 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CheckDockedPanelProperties) { 259 PanelManager* panel_manager = PanelManager::GetInstance(); 260 DockedPanelCollection* docked_collection = panel_manager->docked_collection(); 261 262 // Create 3 docked panels that are in expanded, title-only or minimized states 263 // respectively. 264 Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 100, 100)); 265 Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 100, 100)); 266 Panel* panel3 = CreatePanelWithBounds("3", gfx::Rect(0, 0, 100, 100)); 267 panel2->SetExpansionState(Panel::TITLE_ONLY); 268 EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state()); 269 panel3->SetExpansionState(Panel::MINIMIZED); 270 EXPECT_EQ(Panel::MINIMIZED, panel3->expansion_state()); 271 scoped_ptr<NativePanelTesting> panel1_testing( 272 CreateNativePanelTesting(panel1)); 273 scoped_ptr<NativePanelTesting> panel2_testing( 274 CreateNativePanelTesting(panel2)); 275 scoped_ptr<NativePanelTesting> panel3_testing( 276 CreateNativePanelTesting(panel3)); 277 278 // Ensure that the layout message can get a chance to be processed so that 279 // the button visibility can be updated. 280 base::MessageLoop::current()->RunUntilIdle(); 281 282 EXPECT_EQ(3, panel_manager->num_panels()); 283 EXPECT_TRUE(docked_collection->HasPanel(panel1)); 284 EXPECT_TRUE(docked_collection->HasPanel(panel2)); 285 EXPECT_TRUE(docked_collection->HasPanel(panel3)); 286 287 EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state()); 288 EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state()); 289 EXPECT_EQ(Panel::MINIMIZED, panel3->expansion_state()); 290 291 EXPECT_TRUE(panel1->IsAlwaysOnTop()); 292 EXPECT_TRUE(panel2->IsAlwaysOnTop()); 293 EXPECT_TRUE(panel3->IsAlwaysOnTop()); 294 295 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 296 EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 297 EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 298 299 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 300 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 301 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 302 303 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 304 EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 305 EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 306 307 // Expanded panel cannot be resized at the bottom. 308 EXPECT_EQ(panel::RESIZABLE_EXCEPT_BOTTOM, panel1->CanResizeByMouse()); 309 EXPECT_EQ(panel::NOT_RESIZABLE, panel2->CanResizeByMouse()); 310 EXPECT_EQ(panel::NOT_RESIZABLE, panel3->CanResizeByMouse()); 311 312 EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle()); 313 EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle()); 314 EXPECT_EQ(panel::TOP_ROUNDED, panel3_testing->GetWindowCornerStyle()); 315 316 EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel1->attention_mode()); 317 EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel2->attention_mode()); 318 EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel3->attention_mode()); 319 320 panel_manager->CloseAll(); 321 } 322 323 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) { 324 PanelManager* panel_manager = PanelManager::GetInstance(); 325 EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially. 326 327 Panel* panel = CreatePanel("PanelTest"); 328 EXPECT_EQ(1, panel_manager->num_panels()); 329 330 gfx::Rect bounds = panel->GetBounds(); 331 EXPECT_GT(bounds.x(), 0); 332 EXPECT_GT(bounds.y(), 0); 333 EXPECT_GT(bounds.width(), 0); 334 EXPECT_GT(bounds.height(), 0); 335 336 EXPECT_EQ(bounds.right(), 337 panel_manager->docked_collection()->StartingRightPosition()); 338 339 CloseWindowAndWait(panel); 340 341 EXPECT_EQ(0, panel_manager->num_panels()); 342 } 343 344 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateBigPanel) { 345 gfx::Rect work_area = PanelManager::GetInstance()-> 346 display_settings_provider()->GetPrimaryWorkArea(); 347 Panel* panel = CreatePanelWithBounds("BigPanel", work_area); 348 gfx::Rect bounds = panel->GetBounds(); 349 EXPECT_EQ(panel->max_size().width(), bounds.width()); 350 EXPECT_LT(bounds.width(), work_area.width()); 351 EXPECT_EQ(panel->max_size().height(), bounds.height()); 352 EXPECT_LT(bounds.height(), work_area.height()); 353 panel->Close(); 354 } 355 356 class WaitForStableInitialSize : public TestPanelNotificationObserver { 357 public: 358 explicit WaitForStableInitialSize(Panel* panel) 359 : TestPanelNotificationObserver( 360 chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED, 361 content::NotificationService::AllSources()), 362 panel_(panel) {} 363 virtual ~WaitForStableInitialSize() {} 364 365 protected: 366 virtual bool AtExpectedState() OVERRIDE { 367 return panel_->GetBounds().height() > panel_->TitleOnlyHeight(); 368 } 369 Panel* panel_; 370 }; 371 372 class WaitForAutoResizeWider : public TestPanelNotificationObserver { 373 public: 374 explicit WaitForAutoResizeWider(Panel* panel) 375 : TestPanelNotificationObserver( 376 chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED, 377 content::NotificationService::AllSources()), 378 panel_(panel), 379 initial_size_(panel->GetBounds().size()) {} 380 virtual ~WaitForAutoResizeWider() {} 381 382 protected: 383 virtual bool AtExpectedState() OVERRIDE { 384 return panel_->GetBounds().width() > initial_size_.width(); 385 } 386 Panel* panel_; 387 gfx::Size initial_size_; 388 }; 389 390 class WaitForAutoResizeNarrower : public TestPanelNotificationObserver { 391 public: 392 explicit WaitForAutoResizeNarrower(Panel* panel) 393 : TestPanelNotificationObserver( 394 chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED, 395 content::NotificationService::AllSources()), 396 panel_(panel), 397 initial_size_(panel->GetBounds().size()) {} 398 virtual ~WaitForAutoResizeNarrower() {} 399 400 protected: 401 virtual bool AtExpectedState() OVERRIDE { 402 return panel_->GetBounds().width() < initial_size_.width(); 403 } 404 Panel* panel_; 405 gfx::Size initial_size_; 406 }; 407 408 // crbug.com/160504 409 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DISABLED_AutoResize) { 410 PanelManager* panel_manager = PanelManager::GetInstance(); 411 panel_manager->enable_auto_sizing(true); 412 // Bigger space is needed by this test. 413 mock_display_settings_provider()->SetPrimaryDisplay( 414 gfx::Rect(0, 0, 1200, 900), gfx::Rect(0, 0, 1200, 900)); 415 416 // Create a test panel with web contents loaded. 417 CreatePanelParams params("PanelTest1", gfx::Rect(), SHOW_AS_ACTIVE); 418 GURL url(ui_test_utils::GetTestUrl( 419 base::FilePath(kTestDir), 420 base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html")))); 421 params.url = url; 422 Panel* panel = CreatePanelWithParams(params); 423 424 // Ensure panel has auto resized to original web content size. 425 // The resize will update the docked panel collection. 426 WaitForStableInitialSize initial_resize(panel); 427 initial_resize.Wait(); 428 gfx::Rect initial_bounds = panel->GetBounds(); 429 430 // Expand the test page. The resize will update the docked panel collection. 431 WaitForAutoResizeWider enlarge(panel); 432 EXPECT_TRUE(content::ExecuteScript( 433 panel->GetWebContents(), "changeSize(50);")); 434 enlarge.Wait(); 435 gfx::Rect bounds_on_grow = panel->GetBounds(); 436 EXPECT_GT(bounds_on_grow.width(), initial_bounds.width()); 437 EXPECT_EQ(bounds_on_grow.height(), initial_bounds.height()); 438 439 // Shrink the test page. The resize will update the docked panel collection. 440 WaitForAutoResizeNarrower shrink(panel); 441 EXPECT_TRUE(content::ExecuteScript( 442 panel->GetWebContents(), "changeSize(-30);")); 443 shrink.Wait(); 444 gfx::Rect bounds_on_shrink = panel->GetBounds(); 445 EXPECT_LT(bounds_on_shrink.width(), bounds_on_grow.width()); 446 EXPECT_GT(bounds_on_shrink.width(), initial_bounds.width()); 447 EXPECT_EQ(bounds_on_shrink.height(), initial_bounds.height()); 448 449 // Verify resizing turns off auto-resizing and panel no longer auto-resizes. 450 gfx::Rect previous_bounds = panel->GetBounds(); 451 // These should be identical because the panel is expanded. 452 EXPECT_EQ(previous_bounds.size(), panel->GetRestoredBounds().size()); 453 gfx::Size new_size(previous_bounds.size()); 454 new_size.Enlarge(5, 5); 455 gfx::Rect new_bounds(previous_bounds.origin(), new_size); 456 panel->SetBounds(new_bounds); 457 EXPECT_FALSE(panel->auto_resizable()); 458 EXPECT_EQ(new_bounds.size(), panel->GetBounds().size()); 459 EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size()); 460 461 // Turn back on auto-resize and verify that panel auto resizes. 462 content::WindowedNotificationObserver auto_resize_enabled( 463 chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED, 464 content::NotificationService::AllSources()); 465 panel->SetAutoResizable(true); 466 auto_resize_enabled.Wait(); 467 gfx::Rect bounds_auto_resize_enabled = panel->GetBounds(); 468 EXPECT_EQ(bounds_on_shrink.width(), bounds_auto_resize_enabled.width()); 469 EXPECT_EQ(bounds_on_shrink.height(), bounds_auto_resize_enabled.height()); 470 471 panel->Close(); 472 } 473 474 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ResizePanel) { 475 PanelManager* panel_manager = PanelManager::GetInstance(); 476 panel_manager->enable_auto_sizing(true); 477 478 Panel* panel = CreatePanel("TestPanel"); 479 EXPECT_TRUE(panel->auto_resizable()); 480 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 481 482 // Verify resizing turns off auto-resizing and that it works. 483 gfx::Rect original_bounds = panel->GetBounds(); 484 // These should be identical because the panel is expanded. 485 EXPECT_EQ(original_bounds.size(), panel->GetRestoredBounds().size()); 486 gfx::Size new_size(original_bounds.size()); 487 new_size.Enlarge(5, 5); 488 gfx::Rect new_bounds(original_bounds.origin(), new_size); 489 panel->SetBounds(new_bounds); 490 EXPECT_FALSE(panel->auto_resizable()); 491 EXPECT_EQ(new_bounds.size(), panel->GetBounds().size()); 492 EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size()); 493 494 // Verify current height unaffected when panel is not expanded. 495 panel->SetExpansionState(Panel::MINIMIZED); 496 int original_height = panel->GetBounds().height(); 497 new_size.Enlarge(5, 5); 498 new_bounds.set_size(new_size); 499 panel->SetBounds(new_bounds); 500 EXPECT_EQ(new_bounds.size().width(), panel->GetBounds().width()); 501 EXPECT_EQ(original_height, panel->GetBounds().height()); 502 EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size()); 503 504 panel->Close(); 505 } 506 507 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, AnimateBounds) { 508 // Create a detached panel, instead of docked panel because it cannot be 509 // moved to any location. 510 Panel* panel = CreateDetachedPanel("1", gfx::Rect(200, 100, 100, 100)); 511 scoped_ptr<NativePanelTesting> panel_testing( 512 CreateNativePanelTesting(panel)); 513 514 // Validates that no animation should be triggered when the panel is being 515 // dragged. 516 gfx::Point mouse_location(panel->GetBounds().origin()); 517 panel_testing->PressLeftMouseButtonTitlebar(mouse_location); 518 panel_testing->DragTitlebar(mouse_location + gfx::Vector2d(-100, 5)); 519 EXPECT_FALSE(panel_testing->IsAnimatingBounds()); 520 panel_testing->FinishDragTitlebar(); 521 522 // Set bounds with animation. 523 gfx::Rect bounds = gfx::Rect(10, 20, 150, 160); 524 panel->SetPanelBounds(bounds); 525 EXPECT_TRUE(panel_testing->IsAnimatingBounds()); 526 WaitForBoundsAnimationFinished(panel); 527 EXPECT_FALSE(panel_testing->IsAnimatingBounds()); 528 EXPECT_EQ(bounds, panel->GetBounds()); 529 530 // Set bounds without animation. 531 bounds = gfx::Rect(30, 40, 200, 220); 532 panel->SetPanelBoundsInstantly(bounds); 533 EXPECT_FALSE(panel_testing->IsAnimatingBounds()); 534 EXPECT_EQ(bounds, panel->GetBounds()); 535 536 panel->Close(); 537 } 538 539 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, RestoredBounds) { 540 Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 100, 100)); 541 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 542 EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds()); 543 544 panel->SetExpansionState(Panel::MINIMIZED); 545 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 546 gfx::Rect bounds = panel->GetBounds(); 547 gfx::Rect restored = panel->GetRestoredBounds(); 548 EXPECT_EQ(bounds.x(), restored.x()); 549 EXPECT_GT(bounds.y(), restored.y()); 550 EXPECT_EQ(bounds.width(), restored.width()); 551 EXPECT_LT(bounds.height(), restored.height()); 552 553 panel->SetExpansionState(Panel::TITLE_ONLY); 554 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); 555 bounds = panel->GetBounds(); 556 restored = panel->GetRestoredBounds(); 557 EXPECT_EQ(bounds.x(), restored.x()); 558 EXPECT_GT(bounds.y(), restored.y()); 559 EXPECT_EQ(bounds.width(), restored.width()); 560 EXPECT_LT(bounds.height(), restored.height()); 561 562 panel->SetExpansionState(Panel::MINIMIZED); 563 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 564 bounds = panel->GetBounds(); 565 restored = panel->GetRestoredBounds(); 566 EXPECT_EQ(bounds.x(), restored.x()); 567 EXPECT_GT(bounds.y(), restored.y()); 568 EXPECT_EQ(bounds.width(), restored.width()); 569 EXPECT_LT(bounds.height(), restored.height()); 570 571 panel->SetExpansionState(Panel::EXPANDED); 572 EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds()); 573 574 // Verify that changing the panel bounds does not affect the restored height. 575 int saved_restored_height = restored.height(); 576 panel->SetExpansionState(Panel::MINIMIZED); 577 bounds = gfx::Rect(10, 20, 300, 400); 578 panel->SetPanelBounds(bounds); 579 EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height()); 580 581 panel->SetExpansionState(Panel::TITLE_ONLY); 582 bounds = gfx::Rect(20, 30, 100, 200); 583 panel->SetPanelBounds(bounds); 584 EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height()); 585 586 panel->SetExpansionState(Panel::EXPANDED); 587 bounds = gfx::Rect(40, 60, 300, 400); 588 panel->SetPanelBounds(bounds); 589 EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height()); 590 panel->set_full_size(bounds.size()); 591 EXPECT_NE(saved_restored_height, panel->GetRestoredBounds().height()); 592 593 panel->Close(); 594 } 595 596 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestore) { 597 // Test with one panel. 598 CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100)); 599 TestMinimizeRestore(); 600 601 PanelManager::GetInstance()->CloseAll(); 602 } 603 604 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreTwoPanels) { 605 // Test with two panels. 606 CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100)); 607 CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110)); 608 TestMinimizeRestore(); 609 610 PanelManager::GetInstance()->CloseAll(); 611 } 612 613 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreThreePanels) { 614 // Test with three panels. 615 CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100)); 616 CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110)); 617 CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 120, 120)); 618 TestMinimizeRestore(); 619 620 PanelManager::GetInstance()->CloseAll(); 621 } 622 623 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreButtonClick) { 624 // Test with three panels. 625 Panel* panel1 = CreatePanel("PanelTest1"); 626 Panel* panel2 = CreatePanel("PanelTest2"); 627 Panel* panel3 = CreatePanel("PanelTest3"); 628 EXPECT_FALSE(panel1->IsMinimized()); 629 EXPECT_FALSE(panel2->IsMinimized()); 630 EXPECT_FALSE(panel3->IsMinimized()); 631 632 // Click restore button on an expanded panel. Expect no change. 633 panel1->OnRestoreButtonClicked(panel::NO_MODIFIER); 634 EXPECT_FALSE(panel1->IsMinimized()); 635 EXPECT_FALSE(panel2->IsMinimized()); 636 EXPECT_FALSE(panel3->IsMinimized()); 637 638 // Click minimize button on an expanded panel. Only that panel will minimize. 639 panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER); 640 EXPECT_TRUE(panel1->IsMinimized()); 641 EXPECT_FALSE(panel2->IsMinimized()); 642 EXPECT_FALSE(panel3->IsMinimized()); 643 644 // Click minimize button on a minimized panel. Expect no change. 645 panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER); 646 EXPECT_TRUE(panel1->IsMinimized()); 647 EXPECT_FALSE(panel2->IsMinimized()); 648 EXPECT_FALSE(panel3->IsMinimized()); 649 650 // Minimize all panels by clicking minimize button on an expanded panel 651 // with the apply-all modifier. 652 panel2->OnMinimizeButtonClicked(panel::APPLY_TO_ALL); 653 EXPECT_TRUE(panel1->IsMinimized()); 654 EXPECT_TRUE(panel2->IsMinimized()); 655 EXPECT_TRUE(panel3->IsMinimized()); 656 657 // Click restore button on a minimized panel. Only that panel will restore. 658 panel2->OnRestoreButtonClicked(panel::NO_MODIFIER); 659 EXPECT_TRUE(panel1->IsMinimized()); 660 EXPECT_FALSE(panel2->IsMinimized()); 661 EXPECT_TRUE(panel3->IsMinimized()); 662 663 // Restore all panels by clicking restore button on a minimized panel. 664 panel3->OnRestoreButtonClicked(panel::APPLY_TO_ALL); 665 EXPECT_FALSE(panel1->IsMinimized()); 666 EXPECT_FALSE(panel2->IsMinimized()); 667 EXPECT_FALSE(panel3->IsMinimized()); 668 } 669 670 // http://crbug.com/243891 flaky on Linux 671 #if defined(OS_LINUX) 672 #define MAYBE_RestoreAllWithTitlebarClick DISABLED_RestoreAllWithTitlebarClick 673 #else 674 #define MAYBE_RestoreAllWithTitlebarClick RestoreAllWithTitlebarClick 675 #endif 676 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_RestoreAllWithTitlebarClick) { 677 // Test with three panels. 678 Panel* panel1 = CreatePanel("PanelTest1"); 679 Panel* panel2 = CreatePanel("PanelTest2"); 680 Panel* panel3 = CreatePanel("PanelTest3"); 681 EXPECT_FALSE(panel1->IsMinimized()); 682 EXPECT_FALSE(panel2->IsMinimized()); 683 EXPECT_FALSE(panel3->IsMinimized()); 684 685 scoped_ptr<NativePanelTesting> test_panel1( 686 CreateNativePanelTesting(panel1)); 687 scoped_ptr<NativePanelTesting> test_panel2( 688 CreateNativePanelTesting(panel2)); 689 scoped_ptr<NativePanelTesting> test_panel3( 690 CreateNativePanelTesting(panel3)); 691 692 // Click on an expanded panel's titlebar using the apply-all modifier. 693 // Verify expansion state is unchanged. 694 test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 695 panel::APPLY_TO_ALL); 696 test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 697 EXPECT_FALSE(panel1->IsMinimized()); 698 EXPECT_FALSE(panel2->IsMinimized()); 699 EXPECT_FALSE(panel3->IsMinimized()); 700 701 // Click on a minimized panel's titlebar using the apply-all modifier. 702 panel1->Minimize(); 703 panel2->Minimize(); 704 panel3->Minimize(); 705 EXPECT_TRUE(panel1->IsMinimized()); 706 EXPECT_TRUE(panel2->IsMinimized()); 707 EXPECT_TRUE(panel3->IsMinimized()); 708 709 // Nothing changes until mouse is released. 710 test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(), 711 panel::APPLY_TO_ALL); 712 EXPECT_TRUE(panel1->IsMinimized()); 713 EXPECT_TRUE(panel2->IsMinimized()); 714 EXPECT_TRUE(panel3->IsMinimized()); 715 // Verify all panels restored when mouse is released. 716 test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 717 EXPECT_FALSE(panel1->IsMinimized()); 718 EXPECT_FALSE(panel2->IsMinimized()); 719 EXPECT_FALSE(panel3->IsMinimized()); 720 721 // Minimize a single panel. Then click on expanded panel with apply-all 722 // modifier. Verify nothing changes. 723 panel1->Minimize(); 724 EXPECT_TRUE(panel1->IsMinimized()); 725 EXPECT_FALSE(panel2->IsMinimized()); 726 EXPECT_FALSE(panel3->IsMinimized()); 727 728 test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 729 panel::APPLY_TO_ALL); 730 test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 731 EXPECT_TRUE(panel1->IsMinimized()); 732 EXPECT_FALSE(panel2->IsMinimized()); 733 EXPECT_FALSE(panel3->IsMinimized()); 734 735 // Minimize another panel. Then click on a minimized panel with apply-all 736 // modifier to restore all panels. 737 panel2->Minimize(); 738 EXPECT_TRUE(panel1->IsMinimized()); 739 EXPECT_TRUE(panel2->IsMinimized()); 740 EXPECT_FALSE(panel3->IsMinimized()); 741 742 test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 743 panel::APPLY_TO_ALL); 744 test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 745 EXPECT_FALSE(panel1->IsMinimized()); 746 EXPECT_FALSE(panel2->IsMinimized()); 747 EXPECT_FALSE(panel3->IsMinimized()); 748 749 // Click on the single minimized panel. Verify all are restored. 750 panel1->Minimize(); 751 EXPECT_TRUE(panel1->IsMinimized()); 752 EXPECT_FALSE(panel2->IsMinimized()); 753 EXPECT_FALSE(panel3->IsMinimized()); 754 755 test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(), 756 panel::APPLY_TO_ALL); 757 test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 758 EXPECT_FALSE(panel1->IsMinimized()); 759 EXPECT_FALSE(panel2->IsMinimized()); 760 EXPECT_FALSE(panel3->IsMinimized()); 761 762 // Click on the single expanded panel. Verify nothing changes. 763 panel1->Minimize(); 764 panel3->Minimize(); 765 EXPECT_TRUE(panel1->IsMinimized()); 766 EXPECT_FALSE(panel2->IsMinimized()); 767 EXPECT_TRUE(panel3->IsMinimized()); 768 769 test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 770 panel::APPLY_TO_ALL); 771 test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 772 EXPECT_TRUE(panel1->IsMinimized()); 773 EXPECT_FALSE(panel2->IsMinimized()); 774 EXPECT_TRUE(panel3->IsMinimized()); 775 776 // Hover over a minimized panel and click on the titlebar while it is in 777 // title-only mode. Should restore all panels. 778 panel2->Minimize(); 779 EXPECT_TRUE(panel1->IsMinimized()); 780 EXPECT_TRUE(panel2->IsMinimized()); 781 EXPECT_TRUE(panel3->IsMinimized()); 782 783 MoveMouseAndWaitForExpansionStateChange(panel2, panel2->GetBounds().origin()); 784 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 785 EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state()); 786 EXPECT_EQ(Panel::TITLE_ONLY, panel3->expansion_state()); 787 788 test_panel3->PressLeftMouseButtonTitlebar(panel3->GetBounds().origin(), 789 panel::APPLY_TO_ALL); 790 test_panel3->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 791 EXPECT_FALSE(panel1->IsMinimized()); 792 EXPECT_FALSE(panel2->IsMinimized()); 793 EXPECT_FALSE(panel3->IsMinimized()); 794 795 // Draw attention to a minimized panel. Click on a minimized panel that is 796 // not drawing attention. Verify restore all applies without affecting 797 // draw attention. 798 panel1->Minimize(); 799 panel2->Minimize(); 800 panel3->Minimize(); 801 EXPECT_TRUE(panel1->IsMinimized()); 802 EXPECT_TRUE(panel2->IsMinimized()); 803 EXPECT_TRUE(panel3->IsMinimized()); 804 805 panel1->FlashFrame(true); 806 EXPECT_TRUE(panel1->IsDrawingAttention()); 807 808 test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 809 panel::APPLY_TO_ALL); 810 test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 811 EXPECT_FALSE(panel1->IsMinimized()); 812 EXPECT_FALSE(panel2->IsMinimized()); 813 EXPECT_FALSE(panel3->IsMinimized()); 814 EXPECT_TRUE(panel1->IsDrawingAttention()); 815 816 // Restore all panels by clicking on the minimized panel that is drawing 817 // attention. Verify restore all applies and clears draw attention. 818 panel1->Minimize(); 819 panel2->Minimize(); 820 panel3->Minimize(); 821 EXPECT_TRUE(panel1->IsMinimized()); 822 EXPECT_TRUE(panel2->IsMinimized()); 823 EXPECT_TRUE(panel3->IsMinimized()); 824 825 test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(), 826 panel::APPLY_TO_ALL); 827 test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 828 EXPECT_FALSE(panel1->IsMinimized()); 829 EXPECT_FALSE(panel2->IsMinimized()); 830 EXPECT_FALSE(panel3->IsMinimized()); 831 EXPECT_FALSE(panel1->IsDrawingAttention()); 832 833 PanelManager::GetInstance()->CloseAll(); 834 } 835 836 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 837 MinimizeRestoreOnAutoHidingDesktopBar) { 838 PanelManager* panel_manager = PanelManager::GetInstance(); 839 DockedPanelCollection* docked_collection = panel_manager->docked_collection(); 840 int expected_bottom_on_expanded = docked_collection->work_area().bottom(); 841 int expected_bottom_on_title_only = expected_bottom_on_expanded; 842 int expected_bottom_on_minimized = expected_bottom_on_expanded; 843 844 // Turn on auto-hiding. 845 static const int bottom_bar_thickness = 40; 846 mock_display_settings_provider()->EnableAutoHidingDesktopBar( 847 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM, 848 true, 849 bottom_bar_thickness); 850 expected_bottom_on_title_only -= bottom_bar_thickness; 851 852 Panel* panel = CreatePanel("1"); 853 int initial_height = panel->GetBounds().height(); 854 855 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 856 EXPECT_EQ(expected_bottom_on_expanded, panel->GetBounds().bottom()); 857 858 panel->Minimize(); 859 WaitForBoundsAnimationFinished(panel); 860 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 861 EXPECT_EQ(panel::kMinimizedPanelHeight, panel->GetBounds().height()); 862 EXPECT_EQ(expected_bottom_on_minimized, panel->GetBounds().bottom()); 863 864 panel->SetExpansionState(Panel::TITLE_ONLY); 865 WaitForBoundsAnimationFinished(panel); 866 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); 867 EXPECT_EQ(panel::kTitlebarHeight, panel->GetBounds().height()); 868 EXPECT_EQ(expected_bottom_on_title_only, panel->GetBounds().bottom()); 869 870 panel->Restore(); 871 WaitForBoundsAnimationFinished(panel); 872 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 873 EXPECT_EQ(initial_height, panel->GetBounds().height()); 874 EXPECT_EQ(expected_bottom_on_expanded, panel->GetBounds().bottom()); 875 876 panel->Close(); 877 } 878 879 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ChangeAutoHideTaskBarThickness) { 880 PanelManager* manager = PanelManager::GetInstance(); 881 DockedPanelCollection* docked_collection = manager->docked_collection(); 882 int initial_starting_right_position = 883 docked_collection->StartingRightPosition(); 884 885 int bottom_bar_thickness = 20; 886 int right_bar_thickness = 30; 887 mock_display_settings_provider()->EnableAutoHidingDesktopBar( 888 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM, 889 true, 890 bottom_bar_thickness); 891 mock_display_settings_provider()->EnableAutoHidingDesktopBar( 892 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT, 893 true, 894 right_bar_thickness); 895 EXPECT_EQ(initial_starting_right_position, 896 docked_collection->StartingRightPosition()); 897 898 Panel* panel = CreatePanel("PanelTest"); 899 panel->SetExpansionState(Panel::TITLE_ONLY); 900 WaitForBoundsAnimationFinished(panel); 901 902 EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness, 903 panel->GetBounds().bottom()); 904 EXPECT_EQ(docked_collection->StartingRightPosition(), 905 panel->GetBounds().right()); 906 907 initial_starting_right_position = docked_collection->StartingRightPosition(); 908 int bottom_bar_thickness_delta = 10; 909 bottom_bar_thickness += bottom_bar_thickness_delta; 910 int right_bar_thickness_delta = 15; 911 right_bar_thickness += right_bar_thickness_delta; 912 mock_display_settings_provider()->SetDesktopBarThickness( 913 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM, 914 bottom_bar_thickness); 915 mock_display_settings_provider()->SetDesktopBarThickness( 916 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT, 917 right_bar_thickness); 918 base::MessageLoopForUI::current()->RunUntilIdle(); 919 EXPECT_EQ(initial_starting_right_position, 920 docked_collection->StartingRightPosition()); 921 EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness, 922 panel->GetBounds().bottom()); 923 EXPECT_EQ(docked_collection->StartingRightPosition(), 924 panel->GetBounds().right()); 925 926 initial_starting_right_position = docked_collection->StartingRightPosition(); 927 bottom_bar_thickness_delta = 20; 928 bottom_bar_thickness -= bottom_bar_thickness_delta; 929 right_bar_thickness_delta = 10; 930 right_bar_thickness -= right_bar_thickness_delta; 931 mock_display_settings_provider()->SetDesktopBarThickness( 932 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM, 933 bottom_bar_thickness); 934 mock_display_settings_provider()->SetDesktopBarThickness( 935 DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT, 936 right_bar_thickness); 937 base::MessageLoopForUI::current()->RunUntilIdle(); 938 EXPECT_EQ(docked_collection->StartingRightPosition(), 939 initial_starting_right_position); 940 EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness, 941 panel->GetBounds().bottom()); 942 EXPECT_EQ(docked_collection->StartingRightPosition(), 943 panel->GetBounds().right()); 944 945 panel->Close(); 946 } 947 948 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ActivatePanelOrTabbedWindow) { 949 if (!WmSupportWindowActivation()) { 950 LOG(WARNING) << "Skipping test due to WM problems."; 951 return; 952 } 953 954 Panel* panel1 = CreatePanel("Panel1"); 955 Panel* panel2 = CreatePanel("Panel2"); 956 957 // Activate main tabbed window. 958 browser()->window()->Activate(); 959 WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE); 960 961 // Activate a panel. 962 panel2->Activate(); 963 WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE); 964 965 // Activate the main tabbed window back. 966 browser()->window()->Activate(); 967 WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE); 968 969 // Activate another panel. 970 panel1->Activate(); 971 WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE); 972 WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE); 973 974 // Switch focus between panels. 975 panel2->Activate(); 976 WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE); 977 WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE); 978 979 PanelManager::GetInstance()->CloseAll(); 980 } 981 982 // TODO(jianli): To be enabled for other platforms. 983 #if defined(OS_WIN) || defined(OS_LINUX) 984 #define MAYBE_ActivateDeactivateBasic ActivateDeactivateBasic 985 #else 986 #define MAYBE_ActivateDeactivateBasic DISABLED_ActivateDeactivateBasic 987 #endif 988 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateBasic) { 989 if (!WmSupportWindowActivation()) { 990 LOG(WARNING) << "Skipping test due to WM problems."; 991 return; 992 } 993 994 // Create an active panel. 995 Panel* panel = CreatePanel("PanelTest"); 996 scoped_ptr<NativePanelTesting> native_panel_testing( 997 CreateNativePanelTesting(panel)); 998 999 WaitForPanelActiveState(panel, SHOW_AS_ACTIVE); // doublecheck active state 1000 EXPECT_TRUE(native_panel_testing->VerifyActiveState(true)); 1001 1002 // Deactivate the panel. 1003 panel->Deactivate(); 1004 WaitForPanelActiveState(panel, SHOW_AS_INACTIVE); 1005 1006 // On GTK there is no way to deactivate a window. So the Deactivate() call 1007 // above does not actually deactivate the window, but simply lowers it. 1008 #if !defined(OS_LINUX) 1009 EXPECT_TRUE(native_panel_testing->VerifyActiveState(false)); 1010 #endif 1011 1012 // This test does not reactivate the panel because the panel might not be 1013 // reactivated programmatically once it is deactivated. 1014 } 1015 1016 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ActivateDeactivateMultiple) { 1017 if (!WmSupportWindowActivation()) { 1018 LOG(WARNING) << "Skipping test due to WM problems."; 1019 return; 1020 } 1021 1022 BrowserWindow* tabbed_window = browser()->window(); 1023 1024 // Create 4 panels in the following screen layout: 1025 // P3 P2 P1 P0 1026 const int kNumPanels = 4; 1027 for (int i = 0; i < kNumPanels; ++i) 1028 CreatePanelWithBounds(MakePanelName(i), gfx::Rect(0, 0, 100, 100)); 1029 const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels(); 1030 1031 std::vector<bool> expected_active_states; 1032 std::vector<bool> last_active_states; 1033 1034 // The last created panel, P3, should be active. 1035 expected_active_states = ProduceExpectedActiveStates(3); 1036 EXPECT_EQ(expected_active_states, GetAllPanelActiveStates()); 1037 EXPECT_FALSE(tabbed_window->IsActive()); 1038 1039 // Activating P1 should cause P3 to lose focus. 1040 panels[1]->Activate(); 1041 last_active_states = expected_active_states; 1042 expected_active_states = ProduceExpectedActiveStates(1); 1043 WaitForPanelActiveStates(last_active_states, expected_active_states); 1044 EXPECT_EQ(expected_active_states, GetAllPanelActiveStates()); 1045 1046 // Minimizing inactive panel P2 should not affect other panels' active states. 1047 panels[2]->SetExpansionState(Panel::MINIMIZED); 1048 EXPECT_EQ(expected_active_states, GetAllPanelActiveStates()); 1049 EXPECT_FALSE(tabbed_window->IsActive()); 1050 } 1051 1052 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionBasic) { 1053 Panel* panel = CreateInactivePanel("P1"); 1054 scoped_ptr<NativePanelTesting> native_panel_testing( 1055 CreateNativePanelTesting(panel)); 1056 1057 // Test that the attention is drawn when the expanded panel is not in focus. 1058 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 1059 EXPECT_FALSE(panel->IsActive()); 1060 EXPECT_FALSE(panel->IsDrawingAttention()); 1061 panel->FlashFrame(true); 1062 EXPECT_TRUE(panel->IsDrawingAttention()); 1063 EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention()); 1064 1065 // Stop drawing attention. 1066 panel->FlashFrame(false); 1067 EXPECT_FALSE(panel->IsDrawingAttention()); 1068 EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention()); 1069 1070 // Draw attention, then minimize. Titlebar should remain visible. 1071 panel->FlashFrame(true); 1072 EXPECT_TRUE(panel->IsDrawingAttention()); 1073 1074 panel->Minimize(); 1075 EXPECT_TRUE(panel->IsDrawingAttention()); 1076 EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); 1077 1078 // Stop drawing attention. Titlebar should no longer be visible. 1079 panel->FlashFrame(false); 1080 EXPECT_FALSE(panel->IsDrawingAttention()); 1081 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 1082 1083 panel->Close(); 1084 } 1085 1086 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhileMinimized) { 1087 Panel* panel1 = CreateInactivePanel("P1"); 1088 Panel* panel2 = CreateInactivePanel("P2"); 1089 1090 scoped_ptr<NativePanelTesting> native_panel1_testing( 1091 CreateNativePanelTesting(panel1)); 1092 1093 // Test that the attention is drawn and the title-bar is brought up when the 1094 // minimized panel is drawing attention. 1095 panel1->Minimize(); 1096 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1097 panel1->FlashFrame(true); 1098 EXPECT_TRUE(panel1->IsDrawingAttention()); 1099 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1100 EXPECT_TRUE(native_panel1_testing->VerifyDrawingAttention()); 1101 1102 // Test that we cannot bring up other minimized panel if the mouse is over 1103 // the panel that draws attension. 1104 panel2->Minimize(); 1105 gfx::Point hover_point(panel1->GetBounds().origin()); 1106 MoveMouse(hover_point); 1107 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1108 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1109 1110 // Test that we cannot bring down the panel that is drawing the attention. 1111 hover_point.set_y(hover_point.y() - 200); 1112 MoveMouse(hover_point); 1113 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1114 1115 // Test that the attention is cleared when activated. 1116 panel1->Activate(); 1117 WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE); 1118 EXPECT_FALSE(panel1->IsDrawingAttention()); 1119 EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state()); 1120 EXPECT_FALSE(native_panel1_testing->VerifyDrawingAttention()); 1121 1122 PanelManager::GetInstance()->CloseAll(); 1123 } 1124 1125 // Verify that minimized state of a panel is correct after draw attention 1126 // is stopped when there are other minimized panels. 1127 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, StopDrawingAttentionWhileMinimized) { 1128 Panel* panel1 = CreateInactivePanel("P1"); 1129 Panel* panel2 = CreateInactivePanel("P2"); 1130 1131 panel1->Minimize(); 1132 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1133 panel2->Minimize(); 1134 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1135 1136 // Verify panel returns to minimized state when no longer drawing attention. 1137 panel1->FlashFrame(true); 1138 EXPECT_TRUE(panel1->IsDrawingAttention()); 1139 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1140 1141 panel1->FlashFrame(false); 1142 EXPECT_FALSE(panel1->IsDrawingAttention()); 1143 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1144 1145 // Hover over other minimized panel to bring up titlebars. 1146 gfx::Point hover_point(panel2->GetBounds().origin()); 1147 MoveMouseAndWaitForExpansionStateChange(panel1, hover_point); 1148 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1149 EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state()); 1150 1151 // Verify panel keeps titlebar visible when no longer drawing attention 1152 // if titlebars are up. 1153 panel1->FlashFrame(true); 1154 EXPECT_TRUE(panel1->IsDrawingAttention()); 1155 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1156 1157 panel1->FlashFrame(false); 1158 EXPECT_FALSE(panel1->IsDrawingAttention()); 1159 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1160 1161 // Move mouse away. All panels should return to minimized state. 1162 hover_point.set_y(hover_point.y() - 200); 1163 MoveMouseAndWaitForExpansionStateChange(panel1, hover_point); 1164 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1165 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1166 1167 // Verify minimized panel that is drawing attention stays in title-only mode 1168 // after attention is cleared if mouse is in the titlebar area. 1169 panel1->FlashFrame(true); 1170 EXPECT_TRUE(panel1->IsDrawingAttention()); 1171 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1172 1173 gfx::Point hover_point_in_panel(panel1->GetBounds().origin()); 1174 MoveMouse(hover_point_in_panel); 1175 1176 panel1->FlashFrame(false); 1177 EXPECT_FALSE(panel1->IsDrawingAttention()); 1178 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1179 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1180 1181 // Typical user scenario will detect the mouse in the panel 1182 // after attention is cleared, causing titles to pop up, so 1183 // we simulate that here. 1184 MoveMouseAndWaitForExpansionStateChange(panel2, hover_point_in_panel); 1185 EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state()); 1186 EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state()); 1187 1188 // Move mouse away and panels should go back to fully minimized state. 1189 MoveMouseAndWaitForExpansionStateChange(panel1, hover_point); 1190 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1191 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1192 1193 PanelManager::GetInstance()->CloseAll(); 1194 } 1195 1196 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhenActive) { 1197 // Create an active panel. 1198 Panel* panel = CreatePanel("P1"); 1199 scoped_ptr<NativePanelTesting> native_panel_testing( 1200 CreateNativePanelTesting(panel)); 1201 1202 // Test that the attention should not be drawn if the expanded panel is in 1203 // focus. 1204 panel->FlashFrame(true); 1205 EXPECT_FALSE(panel->IsDrawingAttention()); 1206 EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention()); 1207 1208 panel->Close(); 1209 } 1210 1211 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnActivate) { 1212 Panel* panel = CreateInactivePanel("P1"); 1213 scoped_ptr<NativePanelTesting> native_panel_testing( 1214 CreateNativePanelTesting(panel)); 1215 1216 panel->FlashFrame(true); 1217 EXPECT_TRUE(panel->IsDrawingAttention()); 1218 EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention()); 1219 1220 // Test that the attention is cleared when panel gets focus. 1221 panel->Activate(); 1222 WaitForPanelActiveState(panel, SHOW_AS_ACTIVE); 1223 EXPECT_FALSE(panel->IsDrawingAttention()); 1224 EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention()); 1225 1226 panel->Close(); 1227 } 1228 1229 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1230 DrawAttentionMinimizedNotResetOnActivate) { 1231 Panel* panel = CreateInactivePanel("P1"); 1232 1233 panel->Minimize(); 1234 EXPECT_TRUE(panel->IsMinimized()); 1235 panel->FlashFrame(true); 1236 EXPECT_TRUE(panel->IsDrawingAttention()); 1237 1238 // Simulate panel being activated while minimized. Cannot call 1239 // Activate() as that expands the panel. 1240 panel->OnActiveStateChanged(true); 1241 EXPECT_TRUE(panel->IsDrawingAttention()); // Unchanged. 1242 1243 // Unminimize panel to show that attention would have been cleared 1244 // if panel had not been minimized. 1245 panel->Restore(); 1246 EXPECT_FALSE(panel->IsMinimized()); 1247 EXPECT_TRUE(panel->IsDrawingAttention()); // Unchanged. 1248 1249 panel->OnActiveStateChanged(true); 1250 EXPECT_FALSE(panel->IsDrawingAttention()); // Attention cleared. 1251 1252 panel->Close(); 1253 } 1254 1255 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnClick) { 1256 Panel* panel = CreateInactivePanel("P1"); 1257 scoped_ptr<NativePanelTesting> native_panel_testing( 1258 CreateNativePanelTesting(panel)); 1259 1260 panel->FlashFrame(true); 1261 EXPECT_TRUE(panel->IsDrawingAttention()); 1262 EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention()); 1263 1264 // Test that the attention is cleared when panel gets focus. 1265 native_panel_testing->PressLeftMouseButtonTitlebar( 1266 panel->GetBounds().origin()); 1267 native_panel_testing->ReleaseMouseButtonTitlebar(); 1268 1269 WaitForPanelActiveState(panel, SHOW_AS_ACTIVE); 1270 EXPECT_FALSE(panel->IsDrawingAttention()); 1271 EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention()); 1272 1273 panel->Close(); 1274 } 1275 1276 // http://crbug.com/175760; several panel tests failing regularly on mac. 1277 #if defined(OS_MACOSX) 1278 #define MAYBE_MinimizeImmediatelyAfterRestore \ 1279 DISABLED_MinimizeImmediatelyAfterRestore 1280 #else 1281 #define MAYBE_MinimizeImmediatelyAfterRestore MinimizeImmediatelyAfterRestore 1282 #endif 1283 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1284 MAYBE_MinimizeImmediatelyAfterRestore) { 1285 CreatePanelParams params("Panel Test", gfx::Rect(), SHOW_AS_ACTIVE); 1286 Panel* panel = CreatePanelWithParams(params); 1287 scoped_ptr<NativePanelTesting> native_panel_testing( 1288 CreateNativePanelTesting(panel)); 1289 1290 PanelActiveStateObserver signal(panel, false); 1291 panel->Minimize(); // this should deactivate. 1292 signal.Wait(); 1293 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 1294 1295 panel->Restore(); 1296 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 1297 1298 // Verify that minimizing a panel right after expansion works. 1299 panel->Minimize(); 1300 EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); 1301 1302 panel->Close(); 1303 } 1304 1305 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, FocusLostOnMinimize) { 1306 CreatePanelParams params("Initially Active", gfx::Rect(), SHOW_AS_ACTIVE); 1307 Panel* panel = CreatePanelWithParams(params); 1308 EXPECT_EQ(Panel::EXPANDED, panel->expansion_state()); 1309 1310 PanelActiveStateObserver signal(panel, false); 1311 panel->Minimize(); 1312 signal.Wait(); 1313 panel->Close(); 1314 } 1315 1316 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateInactiveSwitchToActive) { 1317 Panel* panel = CreateInactivePanel("1"); 1318 1319 panel->Activate(); 1320 WaitForPanelActiveState(panel, SHOW_AS_ACTIVE); 1321 1322 panel->Close(); 1323 } 1324 1325 // TODO(dimich): try/enable on other platforms. See bug 103253 for details on 1326 // why this is disabled on windows. 1327 #if defined(OS_MACOSX) 1328 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \ 1329 MinimizeTwoPanelsWithoutTabbedWindow 1330 #else 1331 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \ 1332 DISABLED_MinimizeTwoPanelsWithoutTabbedWindow 1333 #endif 1334 1335 // When there are 2 panels and no chrome window, minimizing one panel does 1336 // not expand/focuses another. 1337 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1338 MAYBE_MinimizeTwoPanelsWithoutTabbedWindow) { 1339 CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE); 1340 Panel* panel1 = CreatePanelWithParams(params); 1341 Panel* panel2 = CreatePanelWithParams(params); 1342 1343 // Close main tabbed window. 1344 content::WindowedNotificationObserver signal( 1345 chrome::NOTIFICATION_BROWSER_CLOSED, 1346 content::Source<Browser>(browser())); 1347 chrome::CloseWindow(browser()); 1348 signal.Wait(); 1349 1350 EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state()); 1351 EXPECT_EQ(Panel::EXPANDED, panel2->expansion_state()); 1352 panel1->Activate(); 1353 WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE); 1354 1355 panel1->SetExpansionState(Panel::MINIMIZED); 1356 base::MessageLoop::current()->RunUntilIdle(); 1357 WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE); 1358 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1359 1360 panel2->SetExpansionState(Panel::MINIMIZED); 1361 base::MessageLoop::current()->RunUntilIdle(); 1362 WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE); 1363 EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state()); 1364 1365 // Verify that panel1 is still minimized and not active. 1366 WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE); 1367 EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state()); 1368 1369 // Another check for the same. 1370 EXPECT_FALSE(panel1->IsActive()); 1371 EXPECT_FALSE(panel2->IsActive()); 1372 1373 panel1->Close(); 1374 panel2->Close(); 1375 } 1376 1377 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1378 NonExtensionDomainPanelsCloseOnUninstall) { 1379 // Create a test extension. 1380 base::DictionaryValue empty_value; 1381 scoped_refptr<extensions::Extension> extension = 1382 CreateExtension(FILE_PATH_LITERAL("TestExtension"), 1383 extensions::Manifest::INTERNAL, empty_value); 1384 std::string extension_app_name = 1385 web_app::GenerateApplicationNameFromExtensionId(extension->id()); 1386 1387 PanelManager* panel_manager = PanelManager::GetInstance(); 1388 EXPECT_EQ(0, panel_manager->num_panels()); 1389 1390 // Create a panel with the extension as host. 1391 CreatePanelParams params(extension_app_name, gfx::Rect(), SHOW_AS_ACTIVE); 1392 std::string extension_domain_url(extensions::kExtensionScheme); 1393 extension_domain_url += "://"; 1394 extension_domain_url += extension->id(); 1395 extension_domain_url += "/hello.html"; 1396 params.url = GURL(extension_domain_url); 1397 Panel* panel = CreatePanelWithParams(params); 1398 EXPECT_EQ(1, panel_manager->num_panels()); 1399 1400 // Create a panel with a non-extension host. 1401 CreatePanelParams params1(extension_app_name, gfx::Rect(), SHOW_AS_ACTIVE); 1402 params1.url = GURL(url::kAboutBlankURL); 1403 Panel* panel1 = CreatePanelWithParams(params1); 1404 EXPECT_EQ(2, panel_manager->num_panels()); 1405 1406 // Create another extension and a panel from that extension. 1407 scoped_refptr<extensions::Extension> extension_other = 1408 CreateExtension(FILE_PATH_LITERAL("TestExtensionOther"), 1409 extensions::Manifest::INTERNAL, empty_value); 1410 std::string extension_app_name_other = 1411 web_app::GenerateApplicationNameFromExtensionId(extension_other->id()); 1412 Panel* panel_other = CreatePanel(extension_app_name_other); 1413 1414 content::WindowedNotificationObserver signal( 1415 chrome::NOTIFICATION_PANEL_CLOSED, 1416 content::Source<Panel>(panel)); 1417 content::WindowedNotificationObserver signal1( 1418 chrome::NOTIFICATION_PANEL_CLOSED, 1419 content::Source<Panel>(panel1)); 1420 1421 // Send unload notification on the first extension. 1422 extensions::ExtensionRegistry* registry = 1423 extensions::ExtensionRegistry::Get(browser()->profile()); 1424 registry->RemoveEnabled(extension->id()); 1425 registry->TriggerOnUnloaded( 1426 extension.get(), extensions::UnloadedExtensionInfo::REASON_UNINSTALL); 1427 1428 // Wait for the panels opened by the first extension to close. 1429 signal.Wait(); 1430 signal1.Wait(); 1431 1432 // Verify that the panel that's left is the panel from the second extension. 1433 EXPECT_EQ(panel_other, panel_manager->panels()[0]); 1434 panel_other->Close(); 1435 } 1436 1437 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, OnBeforeUnloadOnClose) { 1438 PanelManager* panel_manager = PanelManager::GetInstance(); 1439 EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially. 1440 1441 const base::string16 title_first_close = base::UTF8ToUTF16("TitleFirstClose"); 1442 const base::string16 title_second_close = 1443 base::UTF8ToUTF16("TitleSecondClose"); 1444 1445 // Create a test panel with web contents loaded. 1446 CreatePanelParams params("PanelTest1", gfx::Rect(0, 0, 300, 300), 1447 SHOW_AS_ACTIVE); 1448 params.url = ui_test_utils::GetTestUrl( 1449 base::FilePath(kTestDir), 1450 base::FilePath(FILE_PATH_LITERAL("onbeforeunload.html"))); 1451 Panel* panel = CreatePanelWithParams(params); 1452 EXPECT_EQ(1, panel_manager->num_panels()); 1453 1454 // Close panel and verify it closes despite having a onbeforeunload handler. 1455 CloseWindowAndWait(panel); 1456 EXPECT_EQ(0, panel_manager->num_panels()); 1457 } 1458 1459 // http://crbug.com/175760; several panel tests failing regularly on mac. 1460 #if defined(OS_MACOSX) 1461 #define MAYBE_SizeClamping DISABLED_SizeClamping 1462 #else 1463 #define MAYBE_SizeClamping SizeClamping 1464 #endif 1465 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_SizeClamping) { 1466 // Using '0' sizes is equivalent of not providing sizes in API and causes 1467 // minimum sizes to be applied to facilitate auto-sizing. 1468 CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE); 1469 Panel* panel = CreatePanelWithParams(params); 1470 EXPECT_EQ(panel->min_size().width(), panel->GetBounds().width()); 1471 EXPECT_EQ(panel->min_size().height(), panel->GetBounds().height()); 1472 int reasonable_width = panel->min_size().width() + 10; 1473 int reasonable_height = panel->min_size().height() + 20; 1474 1475 panel->Close(); 1476 1477 // Using reasonable actual sizes should avoid clamping. 1478 CreatePanelParams params1("Panel1", 1479 gfx::Rect(0, 0, 1480 reasonable_width, reasonable_height), 1481 SHOW_AS_ACTIVE); 1482 panel = CreatePanelWithParams(params1); 1483 EXPECT_EQ(reasonable_width, panel->GetBounds().width()); 1484 EXPECT_EQ(reasonable_height, panel->GetBounds().height()); 1485 panel->Close(); 1486 1487 // Using just one size should auto-compute some reasonable other size. 1488 int given_height = 200; 1489 CreatePanelParams params2("Panel2", gfx::Rect(0, 0, 0, given_height), 1490 SHOW_AS_ACTIVE); 1491 panel = CreatePanelWithParams(params2); 1492 EXPECT_GT(panel->GetBounds().width(), 0); 1493 EXPECT_EQ(given_height, panel->GetBounds().height()); 1494 panel->Close(); 1495 } 1496 1497 // http://crbug.com/175760; several panel tests failing regularly on mac. 1498 // http://crbug.com/179890; TightAutosizeAroundSingleLine broken on Windows by 1499 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1500 DISABLED_TightAutosizeAroundSingleLine) { 1501 PanelManager::GetInstance()->enable_auto_sizing(true); 1502 // Using 0 sizes triggers auto-sizing. 1503 CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE); 1504 params.url = GURL("data:text/html;charset=utf-8,<!doctype html><body>"); 1505 Panel* panel = CreatePanelWithParams(params); 1506 1507 // Ensure panel has auto resized to original web content size. 1508 WaitForStableInitialSize initial_resize(panel); 1509 initial_resize.Wait(); 1510 1511 int initial_width = panel->GetBounds().width(); 1512 int initial_height = panel->GetBounds().height(); 1513 1514 // Inject some HTML content into the panel. 1515 WaitForAutoResizeWider enlarge(panel); 1516 EXPECT_TRUE(content::ExecuteScript( 1517 panel->GetWebContents(), 1518 "document.body.innerHTML =" 1519 " '<nobr>line of text and a <button>Button</button>';")); 1520 enlarge.Wait(); 1521 1522 // The panel should have become larger in both dimensions (the minimums 1523 // has to be set to be smaller then a simple 1-line content, so the autosize 1524 // can work correctly. 1525 EXPECT_GT(panel->GetBounds().width(), initial_width); 1526 EXPECT_GT(panel->GetBounds().height(), initial_height); 1527 1528 panel->Close(); 1529 } 1530 1531 // http://crbug.com/175760; several panel tests failing regularly on mac. 1532 #if defined(OS_MACOSX) 1533 #define MAYBE_DefaultMaxSizeOnDisplaySettingsChange \ 1534 DISABLED_DefaultMaxSizeOnDisplaySettingsChange 1535 #else 1536 #define MAYBE_DefaultMaxSizeOnDisplaySettingsChange \ 1537 DefaultMaxSizeOnDisplaySettingsChange 1538 #endif 1539 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1540 MAYBE_DefaultMaxSizeOnDisplaySettingsChange) { 1541 Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220)); 1542 1543 gfx::Size old_max_size = panel->max_size(); 1544 gfx::Size old_full_size = panel->full_size(); 1545 1546 // Shrink the work area. Expect max size and full size become smaller. 1547 gfx::Rect smaller_work_area(0, 0, 500, 300); 1548 mock_display_settings_provider()->SetPrimaryDisplay( 1549 smaller_work_area, smaller_work_area); 1550 EXPECT_GT(old_max_size.width(), panel->max_size().width()); 1551 EXPECT_GT(old_max_size.height(), panel->max_size().height()); 1552 EXPECT_GT(smaller_work_area.width(), panel->max_size().width()); 1553 EXPECT_GT(smaller_work_area.height(), panel->max_size().height()); 1554 EXPECT_GT(old_full_size.width(), panel->full_size().width()); 1555 EXPECT_GT(old_full_size.height(), panel->full_size().height()); 1556 EXPECT_GE(panel->max_size().width(), panel->full_size().width()); 1557 EXPECT_GE(panel->max_size().height(), panel->full_size().height()); 1558 1559 panel->Close(); 1560 } 1561 1562 // http://crbug.com/175760; several panel tests failing regularly on mac. 1563 #if defined(OS_MACOSX) 1564 #define MAYBE_CustomMaxSizeOnDisplaySettingsChange \ 1565 DISABLED_CustomMaxSizeOnDisplaySettingsChange 1566 #else 1567 #define MAYBE_CustomMaxSizeOnDisplaySettingsChange \ 1568 CustomMaxSizeOnDisplaySettingsChange 1569 #endif 1570 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1571 MAYBE_CustomMaxSizeOnDisplaySettingsChange) { 1572 PanelManager* panel_manager = PanelManager::GetInstance(); 1573 Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220)); 1574 1575 // Trigger custom max size by user resizing. 1576 gfx::Size bigger_size = gfx::Size(550, 400); 1577 gfx::Point mouse_location = panel->GetBounds().origin(); 1578 panel_manager->StartResizingByMouse(panel, 1579 mouse_location, 1580 HTTOPLEFT); 1581 mouse_location.Offset(panel->GetBounds().width() - bigger_size.width(), 1582 panel->GetBounds().height() - bigger_size.height()); 1583 panel_manager->ResizeByMouse(mouse_location); 1584 panel_manager->EndResizingByMouse(false); 1585 1586 gfx::Size old_max_size = panel->max_size(); 1587 EXPECT_EQ(bigger_size, old_max_size); 1588 gfx::Size old_full_size = panel->full_size(); 1589 EXPECT_EQ(bigger_size, old_full_size); 1590 1591 // Shrink the work area. Expect max size and full size become smaller. 1592 gfx::Rect smaller_work_area(0, 0, 500, 300); 1593 mock_display_settings_provider()->SetPrimaryDisplay( 1594 smaller_work_area, smaller_work_area); 1595 EXPECT_GT(old_max_size.width(), panel->max_size().width()); 1596 EXPECT_GT(old_max_size.height(), panel->max_size().height()); 1597 EXPECT_GE(smaller_work_area.width(), panel->max_size().width()); 1598 EXPECT_EQ(smaller_work_area.height(), panel->max_size().height()); 1599 EXPECT_GT(old_full_size.width(), panel->full_size().width()); 1600 EXPECT_GT(old_full_size.height(), panel->full_size().height()); 1601 EXPECT_GE(panel->max_size().width(), panel->full_size().width()); 1602 EXPECT_GE(panel->max_size().height(), panel->full_size().height()); 1603 EXPECT_EQ(smaller_work_area.height(), panel->full_size().height()); 1604 1605 panel->Close(); 1606 } 1607 1608 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DevTools) { 1609 // Create a test panel with web contents loaded. 1610 CreatePanelParams params("1", gfx::Rect(0, 0, 200, 220), SHOW_AS_ACTIVE); 1611 GURL url(ui_test_utils::GetTestUrl( 1612 base::FilePath(kTestDir), 1613 base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html")))); 1614 params.url = url; 1615 Panel* panel = CreatePanelWithParams(params); 1616 1617 // Open devtools. 1618 size_t num_browsers = 1; 1619 EXPECT_EQ(num_browsers, chrome::GetBrowserCount( 1620 browser()->profile(), 1621 browser()->host_desktop_type())); 1622 content::WindowedNotificationObserver signal( 1623 chrome::NOTIFICATION_BROWSER_WINDOW_READY, 1624 content::NotificationService::AllSources()); 1625 EXPECT_TRUE(panel->ExecuteCommandIfEnabled(IDC_DEV_TOOLS)); 1626 signal.Wait(); 1627 1628 // Check that the new browser window that opened is dev tools window. 1629 ++num_browsers; 1630 EXPECT_EQ(num_browsers, chrome::GetBrowserCount( 1631 browser()->profile(), 1632 browser()->host_desktop_type())); 1633 for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) { 1634 if (*iter == browser()) 1635 continue; 1636 ASSERT_TRUE((*iter)->is_devtools()); 1637 } 1638 1639 panel->Close(); 1640 } 1641 1642 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DevToolsConsole) { 1643 // Create a test panel with web contents loaded. 1644 CreatePanelParams params("1", gfx::Rect(0, 0, 200, 220), SHOW_AS_ACTIVE); 1645 GURL url(ui_test_utils::GetTestUrl( 1646 base::FilePath(kTestDir), 1647 base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html")))); 1648 params.url = url; 1649 Panel* panel = CreatePanelWithParams(params); 1650 1651 // Open devtools console. 1652 size_t num_browsers = 1; 1653 EXPECT_EQ(num_browsers, chrome::GetBrowserCount( 1654 browser()->profile(), 1655 browser()->host_desktop_type())); 1656 content::WindowedNotificationObserver signal( 1657 chrome::NOTIFICATION_BROWSER_WINDOW_READY, 1658 content::NotificationService::AllSources()); 1659 EXPECT_TRUE(panel->ExecuteCommandIfEnabled(IDC_DEV_TOOLS_CONSOLE)); 1660 signal.Wait(); 1661 1662 // Check that the new browser window that opened is dev tools window. 1663 ++num_browsers; 1664 EXPECT_EQ(num_browsers, chrome::GetBrowserCount( 1665 browser()->profile(), 1666 browser()->host_desktop_type())); 1667 for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) { 1668 if (*iter == browser()) 1669 continue; 1670 ASSERT_TRUE((*iter)->is_devtools()); 1671 } 1672 1673 panel->Close(); 1674 } 1675 1676 #if defined(OS_WIN) 1677 #define MAYBE_Accelerator Accelerator 1678 #else 1679 #define MAYBE_Accelerator DISABLED_Accelerator 1680 #endif 1681 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_Accelerator) { 1682 PanelManager* panel_manager = PanelManager::GetInstance(); 1683 1684 // Create a test panel with web contents loaded. 1685 CreatePanelParams params("1", gfx::Rect(), SHOW_AS_ACTIVE); 1686 GURL url(ui_test_utils::GetTestUrl( 1687 base::FilePath(kTestDir), 1688 base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html")))); 1689 params.url = url; 1690 Panel* panel = CreatePanelWithParams(params); 1691 EXPECT_EQ(1, panel_manager->num_panels()); 1692 1693 // Close the panel by acclerator. 1694 content::WindowedNotificationObserver signal( 1695 chrome::NOTIFICATION_PANEL_CLOSED, 1696 content::Source<Panel>(panel)); 1697 #if defined(USE_AURA) 1698 double now = ui::EventTimeForNow().InSecondsF(); 1699 content::NativeWebKeyboardEvent key_event( 1700 ui::ET_KEY_PRESSED, 1701 false, 1702 ui::VKEY_W, 1703 ui::EF_CONTROL_DOWN, 1704 now); 1705 #elif defined(OS_WIN) 1706 ::MSG key_msg = { NULL, WM_KEYDOWN, ui::VKEY_W, 0 }; 1707 content::NativeWebKeyboardEvent key_event(key_msg); 1708 key_event.modifiers = content::NativeWebKeyboardEvent::ControlKey; 1709 #else 1710 content::NativeWebKeyboardEvent key_event; 1711 #endif 1712 panel->HandleKeyboardEvent(key_event); 1713 signal.Wait(); 1714 EXPECT_EQ(0, panel_manager->num_panels()); 1715 } 1716 1717 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1718 HideDockedPanelCreatedBeforeFullScreenMode) { 1719 // Create a docked panel. 1720 Panel* panel = CreatePanel("PanelTest"); 1721 scoped_ptr<NativePanelTesting> panel_testing(CreateNativePanelTesting(panel)); 1722 1723 // Panel should be visible at first. 1724 EXPECT_TRUE(panel_testing->IsWindowVisible()); 1725 1726 // Panel should become hidden when entering full-screen mode. 1727 mock_display_settings_provider()->EnableFullScreenMode(true); 1728 EXPECT_FALSE(panel_testing->IsWindowVisible()); 1729 1730 // Panel should become visible when leaving full-screen mode. 1731 mock_display_settings_provider()->EnableFullScreenMode(false); 1732 EXPECT_TRUE(panel_testing->IsWindowVisible()); 1733 1734 PanelManager::GetInstance()->CloseAll(); 1735 } 1736 1737 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 1738 HideDockedPanelCreatedOnFullScreenMode) { 1739 // Enable full-screen mode first. 1740 mock_display_settings_provider()->EnableFullScreenMode(true); 1741 1742 // Create a docked panel without waiting for it to be shown since it is not 1743 // supposed to be shown on full-screen mode. 1744 CreatePanelParams params("1", gfx::Rect(0, 0, 250, 200), SHOW_AS_ACTIVE); 1745 params.wait_for_fully_created = false; 1746 Panel* panel = CreatePanelWithParams(params); 1747 scoped_ptr<NativePanelTesting> panel_testing( 1748 CreateNativePanelTesting(panel)); 1749 1750 // Panel should not be shown on full-screen mode. 1751 EXPECT_FALSE(panel_testing->IsWindowVisible()); 1752 1753 // Panel should become visible when leaving full-screen mode. 1754 mock_display_settings_provider()->EnableFullScreenMode(false); 1755 EXPECT_TRUE(panel_testing->IsWindowVisible()); 1756 1757 PanelManager::GetInstance()->CloseAll(); 1758 } 1759 1760 class PanelExtensionApiTest : public ExtensionApiTest { 1761 protected: 1762 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 1763 ExtensionApiTest::SetUpCommandLine(command_line); 1764 command_line->AppendSwitch(switches::kEnablePanels); 1765 } 1766 }; 1767 1768 #if defined(OS_LINUX) || (!defined(OS_WIN) && defined(USE_AURA)) || \ 1769 defined(OS_MACOSX) 1770 // Focus test fails if there is no window manager on Linux. 1771 // Aura panels have different behavior that do not apply to this test. 1772 #define MAYBE_FocusChangeEventOnMinimize DISABLED_FocusChangeEventOnMinimize 1773 #else 1774 #define MAYBE_FocusChangeEventOnMinimize FocusChangeEventOnMinimize 1775 #endif 1776 IN_PROC_BROWSER_TEST_F(PanelExtensionApiTest, 1777 MAYBE_FocusChangeEventOnMinimize) { 1778 // This is needed so the subsequently created panels can be activated. 1779 // On a Mac, it transforms background-only test process into foreground one. 1780 ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser())); 1781 ASSERT_TRUE(RunExtensionTest("panels/focus_change_on_minimize")) << message_; 1782 } 1783
