chrome/browser/ui/cocoa/panels/panel_cocoa_unittest.mm

   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 <Carbon/Carbon.h>
   6 #import <Cocoa/Cocoa.h>
   7
   8 #include "base/command_line.h"
   9 #include "base/debug/debugger.h"
  10 #include "base/mac/scoped_nsautorelease_pool.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/strings/sys_string_conversions.h"
  13 #include "chrome/app/chrome_command_ids.h"  // IDC_*
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #import "chrome/browser/ui/cocoa/browser_window_utils.h"
  16 #import "chrome/browser/ui/cocoa/cocoa_profile_test.h"
  17 #import "chrome/browser/ui/cocoa/panels/panel_cocoa.h"
  18 #import "chrome/browser/ui/cocoa/panels/panel_titlebar_view_cocoa.h"
  19 #import "chrome/browser/ui/cocoa/panels/panel_window_controller_cocoa.h"
  20 #import "chrome/browser/ui/cocoa/run_loop_testing.h"
  21 #include "chrome/browser/ui/panels/panel.h"
  22 #include "chrome/browser/ui/panels/panel_manager.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "chrome/test/base/testing_profile.h"
  25 #include "content/public/test/test_utils.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "testing/gtest_mac.h"
  28
  29 class PanelAnimatedBoundsObserver :
  30     public content::WindowedNotificationObserver {
  31  public:
  32   PanelAnimatedBoundsObserver(Panel* panel)
  33     : content::WindowedNotificationObserver(
  34         chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
  35         content::Source<Panel>(panel)) { }
  36   virtual ~PanelAnimatedBoundsObserver() { }
  37 };
  38
  39 // Main test class.
  40 class PanelCocoaTest : public CocoaProfileTest {
  41  public:
  42   virtual void SetUp() {
  43     CocoaProfileTest::SetUp();
  44   }
  45
  46   Panel* CreateTestPanel(const std::string& panel_name) {
  47     // Opening panels on a Mac causes NSWindowController of the Panel window
  48     // to be autoreleased. We need a pool drained after it's done so the test
  49     // can close correctly.
  50     base::mac::ScopedNSAutoreleasePool autorelease_pool;
  51
  52     PanelManager* manager = PanelManager::GetInstance();
  53     int panels_count = manager->num_panels();
  54
  55     Panel* panel = manager->CreatePanel(panel_name, profile(),
  56                                         GURL(), gfx::Rect(),
  57                                         PanelManager::CREATE_AS_DOCKED);
  58     EXPECT_EQ(panels_count + 1, manager->num_panels());
  59
  60     EXPECT_TRUE(panel);
  61     EXPECT_TRUE(panel->native_panel());  // Native panel is created right away.
  62     PanelCocoa* native_window =
  63         static_cast<PanelCocoa*>(panel->native_panel());
  64     EXPECT_EQ(panel, native_window->panel_);  // Back pointer initialized.
  65
  66     PanelAnimatedBoundsObserver bounds_observer(panel);
  67
  68     // Window should not load before Show().
  69     // Note: Loading the wnidow causes Cocoa to autorelease a few objects.
  70     // This is the reason we do this within the scope of the
  71     // ScopedNSAutoreleasePool.
  72     EXPECT_FALSE([native_window->controller_ isWindowLoaded]);
  73     panel->Show();
  74     EXPECT_TRUE([native_window->controller_ isWindowLoaded]);
  75     EXPECT_TRUE([native_window->controller_ window]);
  76
  77     // Wait until bounds animate to their specified values.
  78     bounds_observer.Wait();
  79
  80     return panel;
  81   }
  82
  83   void VerifyTitlebarLocation(NSView* contentView, NSView* titlebar) {
  84     NSRect content_frame = [contentView frame];
  85     NSRect titlebar_frame = [titlebar frame];
  86     // Since contentView and titlebar are both children of window's root view,
  87     // we can compare their frames since they are in the same coordinate system.
  88     EXPECT_EQ(NSMinX(content_frame), NSMinX(titlebar_frame));
  89     EXPECT_EQ(NSWidth(content_frame), NSWidth(titlebar_frame));
  90     EXPECT_EQ(NSHeight([[titlebar superview] bounds]), NSMaxY(titlebar_frame));
  91   }
  92
  93   void ClosePanelAndWait(Panel* panel) {
  94     EXPECT_TRUE(panel);
  95     // Closing a panel may involve several async tasks. Need to use
  96     // message pump and wait for the notification.
  97     PanelManager* manager = PanelManager::GetInstance();
  98     int panel_count = manager->num_panels();
  99     content::WindowedNotificationObserver signal(
 100         chrome::NOTIFICATION_PANEL_CLOSED,
 101         content::Source<Panel>(panel));
 102     panel->Close();
 103     signal.Wait();
 104     // Now we have one less panel.
 105     EXPECT_EQ(panel_count - 1, manager->num_panels());
 106   }
 107
 108   NSMenuItem* CreateMenuItem(NSMenu* menu, int command_id) {
 109     NSMenuItem* item =
 110       [menu addItemWithTitle:@""
 111                       action:@selector(commandDispatch:)
 112                keyEquivalent:@""];
 113     [item setTag:command_id];
 114     return item;
 115   }
 116 };
 117
 118 TEST_F(PanelCocoaTest, CreateClose) {
 119   PanelManager* manager = PanelManager::GetInstance();
 120   EXPECT_EQ(0, manager->num_panels());  // No panels initially.
 121
 122   Panel* panel = CreateTestPanel("Test Panel");
 123   ASSERT_TRUE(panel);
 124
 125   gfx::Rect bounds = panel->GetBounds();
 126   EXPECT_TRUE(bounds.width() > 0);
 127   EXPECT_TRUE(bounds.height() > 0);
 128
 129   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 130   ASSERT_TRUE(native_window);
 131   // NSWindows created by NSWindowControllers don't have this bit even if
 132   // their NIB has it. The controller's lifetime is the window's lifetime.
 133   EXPECT_EQ(NO, [[native_window->controller_ window] isReleasedWhenClosed]);
 134
 135   ClosePanelAndWait(panel);
 136   EXPECT_EQ(0, manager->num_panels());
 137 }
 138
 139 TEST_F(PanelCocoaTest, AssignedBounds) {
 140   Panel* panel1 = CreateTestPanel("Test Panel 1");
 141   Panel* panel2 = CreateTestPanel("Test Panel 2");
 142   Panel* panel3 = CreateTestPanel("Test Panel 3");
 143
 144   gfx::Rect bounds1 = panel1->GetBounds();
 145   gfx::Rect bounds2 = panel2->GetBounds();
 146   gfx::Rect bounds3 = panel3->GetBounds();
 147
 148   // This checks panelManager calculating and assigning bounds right.
 149   // Panels should stack on the bottom right to left.
 150   EXPECT_LT(bounds3.x() + bounds3.width(), bounds2.x());
 151   EXPECT_LT(bounds2.x() + bounds2.width(), bounds1.x());
 152   EXPECT_EQ(bounds1.y(), bounds2.y());
 153   EXPECT_EQ(bounds2.y(), bounds3.y());
 154
 155   // After panel2 is closed, panel3 should take its place.
 156   ClosePanelAndWait(panel2);
 157   bounds3 = panel3->GetBounds();
 158   EXPECT_EQ(bounds2, bounds3);
 159
 160   // After panel1 is closed, panel3 should take its place.
 161   ClosePanelAndWait(panel1);
 162   EXPECT_EQ(bounds1, panel3->GetBounds());
 163
 164   ClosePanelAndWait(panel3);
 165 }
 166
 167 // Same test as AssignedBounds, but checks actual bounds on native OS windows.
 168 TEST_F(PanelCocoaTest, NativeBounds) {
 169   Panel* panel1 = CreateTestPanel("Test Panel 1");
 170   Panel* panel2 = CreateTestPanel("Test Panel 2");
 171   Panel* panel3 = CreateTestPanel("Test Panel 3");
 172
 173   PanelCocoa* native_window1 = static_cast<PanelCocoa*>(panel1->native_panel());
 174   PanelCocoa* native_window2 = static_cast<PanelCocoa*>(panel2->native_panel());
 175   PanelCocoa* native_window3 = static_cast<PanelCocoa*>(panel3->native_panel());
 176
 177   NSRect bounds1 = [[native_window1->controller_ window] frame];
 178   NSRect bounds2 = [[native_window2->controller_ window] frame];
 179   NSRect bounds3 = [[native_window3->controller_ window] frame];
 180
 181   EXPECT_LT(bounds3.origin.x + bounds3.size.width, bounds2.origin.x);
 182   EXPECT_LT(bounds2.origin.x + bounds2.size.width, bounds1.origin.x);
 183   EXPECT_EQ(bounds1.origin.y, bounds2.origin.y);
 184   EXPECT_EQ(bounds2.origin.y, bounds3.origin.y);
 185
 186   {
 187     // After panel2 is closed, panel3 should take its place.
 188     PanelAnimatedBoundsObserver bounds_observer(panel3);
 189     ClosePanelAndWait(panel2);
 190     bounds_observer.Wait();
 191     bounds3 = [[native_window3->controller_ window] frame];
 192     EXPECT_EQ(bounds2.origin.x, bounds3.origin.x);
 193     EXPECT_EQ(bounds2.origin.y, bounds3.origin.y);
 194     EXPECT_EQ(bounds2.size.width, bounds3.size.width);
 195     EXPECT_EQ(bounds2.size.height, bounds3.size.height);
 196   }
 197
 198   {
 199     // After panel1 is closed, panel3 should take its place.
 200     PanelAnimatedBoundsObserver bounds_observer(panel3);
 201     ClosePanelAndWait(panel1);
 202     bounds_observer.Wait();
 203     bounds3 = [[native_window3->controller_ window] frame];
 204     EXPECT_EQ(bounds1.origin.x, bounds3.origin.x);
 205     EXPECT_EQ(bounds1.origin.y, bounds3.origin.y);
 206     EXPECT_EQ(bounds1.size.width, bounds3.size.width);
 207     EXPECT_EQ(bounds1.size.height, bounds3.size.height);
 208   }
 209
 210   ClosePanelAndWait(panel3);
 211 }
 212
 213 // Verify the titlebar is being created.
 214 TEST_F(PanelCocoaTest, TitlebarViewCreate) {
 215   Panel* panel = CreateTestPanel("Test Panel");
 216
 217   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 218
 219   PanelTitlebarViewCocoa* titlebar = [native_window->controller_ titlebarView];
 220   EXPECT_TRUE(titlebar);
 221   EXPECT_EQ(native_window->controller_, [titlebar controller]);
 222
 223   ClosePanelAndWait(panel);
 224 }
 225
 226 // Verify the sizing of titlebar - should be affixed on top of regular titlebar.
 227 TEST_F(PanelCocoaTest, TitlebarViewSizing) {
 228   Panel* panel = CreateTestPanel("Test Panel");
 229
 230   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 231   PanelTitlebarViewCocoa* titlebar = [native_window->controller_ titlebarView];
 232
 233   NSView* contentView = [[native_window->controller_ window] contentView];
 234   VerifyTitlebarLocation(contentView, titlebar);
 235
 236   // In local coordinate system, width of titlebar should match width of
 237   // content view of the window. They both use the same scale factor.
 238   EXPECT_EQ(NSWidth([contentView bounds]), NSWidth([titlebar bounds]));
 239
 240   NSRect oldTitleFrame = [[titlebar title] frame];
 241   NSRect oldIconFrame = [[titlebar icon] frame];
 242
 243   // Now resize the Panel, see that titlebar follows.
 244   const int kDelta = 153;  // random number
 245   gfx::Rect bounds = panel->GetBounds();
 246   // Grow panel in a way so that its titlebar moves and grows.
 247   bounds.set_x(bounds.x() - kDelta);
 248   bounds.set_y(bounds.y() - kDelta);
 249   bounds.set_width(bounds.width() + kDelta);
 250   bounds.set_height(bounds.height() + kDelta);
 251
 252   PanelAnimatedBoundsObserver bounds_observer(panel);
 253   native_window->SetPanelBounds(bounds);
 254   bounds_observer.Wait();
 255
 256   // Verify the panel resized.
 257   NSRect window_frame = [[native_window->controller_ window] frame];
 258   EXPECT_EQ(NSWidth(window_frame), bounds.width());
 259   EXPECT_EQ(NSHeight(window_frame), bounds.height());
 260
 261   // Verify the titlebar is still on top of regular titlebar.
 262   VerifyTitlebarLocation(contentView, titlebar);
 263
 264   // Verify that the title/icon frames were updated.
 265   NSRect newTitleFrame = [[titlebar title] frame];
 266   NSRect newIconFrame = [[titlebar icon] frame];
 267
 268   EXPECT_EQ(newTitleFrame.origin.x - newIconFrame.origin.x,
 269             oldTitleFrame.origin.x - oldIconFrame.origin.x);
 270   // Icon and Text should remain at the same left-aligned position.
 271   EXPECT_EQ(newTitleFrame.origin.x, oldTitleFrame.origin.x);
 272   EXPECT_EQ(newIconFrame.origin.x, oldIconFrame.origin.x);
 273
 274   ClosePanelAndWait(panel);
 275 }
 276
 277 // Verify closing behavior of titlebar close button.
 278 TEST_F(PanelCocoaTest, TitlebarViewClose) {
 279   Panel* panel = CreateTestPanel("Test Panel");
 280   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 281
 282   PanelTitlebarViewCocoa* titlebar = [native_window->controller_ titlebarView];
 283   EXPECT_TRUE(titlebar);
 284
 285   PanelManager* manager = PanelManager::GetInstance();
 286   EXPECT_EQ(1, manager->num_panels());
 287   // Simulate clicking Close Button and wait until the Panel closes.
 288   content::WindowedNotificationObserver signal(
 289       chrome::NOTIFICATION_PANEL_CLOSED,
 290       content::Source<Panel>(panel));
 291   [titlebar simulateCloseButtonClick];
 292   signal.Wait();
 293   EXPECT_EQ(0, manager->num_panels());
 294 }
 295
 296 // Verify some menu items being properly enabled/disabled for panels.
 297 TEST_F(PanelCocoaTest, MenuItems) {
 298   Panel* panel = CreateTestPanel("Test Panel");
 299
 300   base::scoped_nsobject<NSMenu> menu([[NSMenu alloc] initWithTitle:@""]);
 301   NSMenuItem* close_tab_menu_item = CreateMenuItem(menu, IDC_CLOSE_TAB);
 302   NSMenuItem* new_tab_menu_item = CreateMenuItem(menu, IDC_NEW_TAB);
 303   NSMenuItem* new_tab_window_item = CreateMenuItem(menu, IDC_NEW_WINDOW);
 304   NSMenuItem* new_tab_incognito_window_item =
 305       CreateMenuItem(menu, IDC_NEW_INCOGNITO_WINDOW);
 306   NSMenuItem* close_window_menu_item = CreateMenuItem(menu, IDC_CLOSE_WINDOW);
 307   NSMenuItem* find_menu_item = CreateMenuItem(menu, IDC_FIND);
 308   NSMenuItem* find_previous_menu_item = CreateMenuItem(menu, IDC_FIND_PREVIOUS);
 309   NSMenuItem* find_next_menu_item = CreateMenuItem(menu, IDC_FIND_NEXT);
 310   NSMenuItem* fullscreen_menu_item = CreateMenuItem(menu, IDC_FULLSCREEN);
 311   NSMenuItem* presentation_menu_item =
 312       CreateMenuItem(menu, IDC_PRESENTATION_MODE);
 313   NSMenuItem* sync_menu_item = CreateMenuItem(menu, IDC_SHOW_SYNC_SETUP);
 314   NSMenuItem* dev_tools_item = CreateMenuItem(menu, IDC_DEV_TOOLS);
 315   NSMenuItem* dev_tools_console_item =
 316       CreateMenuItem(menu, IDC_DEV_TOOLS_CONSOLE);
 317
 318   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 319   PanelWindowControllerCocoa* panel_controller = native_window->controller_;
 320   for (NSMenuItem *item in [menu itemArray])
 321     [item setTarget:panel_controller];
 322
 323   [menu update];  // Trigger validation of menu items.
 324   EXPECT_FALSE([close_tab_menu_item isEnabled]);
 325   EXPECT_TRUE([close_window_menu_item isEnabled]);
 326   // No find support. Panels don't have a find bar.
 327   EXPECT_FALSE([find_menu_item isEnabled]);
 328   EXPECT_FALSE([find_previous_menu_item isEnabled]);
 329   EXPECT_FALSE([find_next_menu_item isEnabled]);
 330   EXPECT_FALSE([fullscreen_menu_item isEnabled]);
 331   EXPECT_FALSE([presentation_menu_item isEnabled]);
 332   EXPECT_FALSE([sync_menu_item isEnabled]);
 333   // These are not enabled by Panel, so they are expected to be disabled for
 334   // this unit_test. In real Chrome app, they are enabled by Chrome NSApp
 335   // controller. PanelCocoaBrowsertest.MenuItems verifies that.
 336   EXPECT_FALSE([new_tab_menu_item isEnabled]);
 337   EXPECT_FALSE([new_tab_window_item isEnabled]);
 338   EXPECT_FALSE([new_tab_incognito_window_item isEnabled]);
 339
 340   EXPECT_TRUE([dev_tools_item isEnabled]);
 341   EXPECT_TRUE([dev_tools_console_item isEnabled]);
 342
 343   // Verify that commandDispatch on an invalid menu item does not crash.
 344   [NSApp sendAction:[sync_menu_item action]
 345                  to:[sync_menu_item target]
 346                from:sync_menu_item];
 347
 348   ClosePanelAndWait(panel);
 349 }
 350
 351 TEST_F(PanelCocoaTest, KeyEvent) {
 352   Panel* panel = CreateTestPanel("Test Panel");
 353   NSEvent* event = [NSEvent keyEventWithType:NSKeyDown
 354                                     location:NSZeroPoint
 355                                modifierFlags:NSControlKeyMask
 356                                    timestamp:0.0
 357                                 windowNumber:0
 358                                      context:nil
 359                                   characters:@""
 360                  charactersIgnoringModifiers:@""
 361                                    isARepeat:NO
 362                                      keyCode:kVK_Tab];
 363   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 364   [BrowserWindowUtils handleKeyboardEvent:event
 365                       inWindow:[native_window->controller_ window]];
 366   ClosePanelAndWait(panel);
 367 }
 368
 369 TEST_F(PanelCocoaTest, SetTitle) {
 370   NSString *appName = @"Test Panel";
 371   Panel* panel = CreateTestPanel(base::SysNSStringToUTF8(appName));
 372   ASSERT_TRUE(panel);
 373
 374   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 375   ASSERT_TRUE(native_window);
 376   NSString* previousTitle = [[native_window->controller_ window] title];
 377   EXPECT_NSNE(appName, previousTitle);
 378   [native_window->controller_ updateTitleBar];
 379   chrome::testing::NSRunLoopRunAllPending();
 380   NSString* currentTitle = [[native_window->controller_ window] title];
 381   EXPECT_NSEQ(appName, currentTitle);
 382   EXPECT_NSNE(currentTitle, previousTitle);
 383   ClosePanelAndWait(panel);
 384 }
 385
 386 TEST_F(PanelCocoaTest, ActivatePanel) {
 387   Panel* panel = CreateTestPanel("Test Panel");
 388   Panel* panel2 = CreateTestPanel("Test Panel 2");
 389   ASSERT_TRUE(panel);
 390   ASSERT_TRUE(panel2);
 391
 392   PanelCocoa* native_window = static_cast<PanelCocoa*>(panel->native_panel());
 393   ASSERT_TRUE(native_window);
 394   PanelCocoa* native_window2 = static_cast<PanelCocoa*>(panel2->native_panel());
 395   ASSERT_TRUE(native_window2);
 396
 397   // No one has a good answer why but apparently windows can't take keyboard
 398   // focus outside of interactive UI tests. BrowserWindowController uses the
 399   // same way of testing this.
 400   native_window->ActivatePanel();
 401   NSWindow* frontmostWindow = [[NSApp orderedWindows] objectAtIndex:0];
 402   EXPECT_NSEQ(frontmostWindow, [native_window->controller_ window]);
 403
 404   native_window2->ActivatePanel();
 405   frontmostWindow = [[NSApp orderedWindows] objectAtIndex:0];
 406   EXPECT_NSEQ(frontmostWindow, [native_window2->controller_ window]);
 407
 408   ClosePanelAndWait(panel);
 409   ClosePanelAndWait(panel2);
 410 }