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
29class 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.
40class 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
118TEST_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
139TEST_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.
168TEST_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.
214TEST_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.
227TEST_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.
278TEST_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.
297TEST_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
351TEST_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
369TEST_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
386TEST_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}
411