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// This functionality currently works on Windows and on Linux when
6// toolkit_views is defined (i.e. for Chrome OS). It's not needed
7// on the Mac, and it's not yet implemented on Linux.
8
9#include "base/memory/weak_ptr.h"
10#include "base/message_loop/message_loop.h"
11#include "base/strings/string_util.h"
12#include "base/time/time.h"
13#include "chrome/browser/chrome_notification_types.h"
14#include "chrome/browser/ui/browser.h"
15#include "chrome/browser/ui/browser_window.h"
16#include "chrome/browser/ui/tabs/tab_strip_model.h"
17#include "chrome/browser/ui/views/frame/browser_view.h"
18#include "chrome/browser/ui/views/toolbar/toolbar_view.h"
19#include "chrome/test/base/in_process_browser_test.h"
20#include "chrome/test/base/interactive_test_utils.h"
21#include "chrome/test/base/ui_test_utils.h"
22#include "ui/base/test/ui_controls.h"
23#include "ui/events/event_constants.h"
24#include "ui/events/keycodes/keyboard_codes.h"
25#include "ui/views/controls/menu/menu_listener.h"
26#include "ui/views/focus/focus_manager.h"
27#include "ui/views/view.h"
28#include "ui/views/widget/widget.h"
29
30namespace {
31
32// An async version of SendKeyPressSync since we don't get notified when a
33// menu is showing.
34void SendKeyPress(Browser* browser, ui::KeyboardCode key) {
35  ASSERT_TRUE(ui_controls::SendKeyPress(
36      browser->window()->GetNativeWindow(), key, false, false, false, false));
37}
38
39// Helper class that waits until the focus has changed to a view other
40// than the one with the provided view id.
41class ViewFocusChangeWaiter : public views::FocusChangeListener {
42 public:
43  ViewFocusChangeWaiter(views::FocusManager* focus_manager,
44                        int previous_view_id)
45      : focus_manager_(focus_manager),
46        previous_view_id_(previous_view_id),
47        weak_factory_(this) {
48    focus_manager_->AddFocusChangeListener(this);
49    // Call the focus change notification once in case the focus has
50    // already changed.
51    OnWillChangeFocus(NULL, focus_manager_->GetFocusedView());
52  }
53
54  virtual ~ViewFocusChangeWaiter() {
55    focus_manager_->RemoveFocusChangeListener(this);
56  }
57
58  void Wait() {
59    content::RunMessageLoop();
60  }
61
62 private:
63  // Inherited from FocusChangeListener
64  virtual void OnWillChangeFocus(views::View* focused_before,
65                                 views::View* focused_now) OVERRIDE {
66  }
67
68  virtual void OnDidChangeFocus(views::View* focused_before,
69                                views::View* focused_now) OVERRIDE {
70    if (focused_now && focused_now->id() != previous_view_id_) {
71      base::MessageLoop::current()->PostTask(FROM_HERE,
72                                             base::MessageLoop::QuitClosure());
73    }
74  }
75
76  views::FocusManager* focus_manager_;
77  int previous_view_id_;
78  base::WeakPtrFactory<ViewFocusChangeWaiter> weak_factory_;
79
80  DISALLOW_COPY_AND_ASSIGN(ViewFocusChangeWaiter);
81};
82
83class SendKeysMenuListener : public views::MenuListener {
84 public:
85  SendKeysMenuListener(ToolbarView* toolbar_view,
86                       Browser* browser,
87                       bool test_dismiss_menu)
88      : toolbar_view_(toolbar_view), browser_(browser), menu_open_count_(0),
89        test_dismiss_menu_(test_dismiss_menu) {
90    toolbar_view_->AddMenuListener(this);
91  }
92
93  virtual ~SendKeysMenuListener() {
94    if (test_dismiss_menu_)
95      toolbar_view_->RemoveMenuListener(this);
96  }
97
98  int menu_open_count() const {
99    return menu_open_count_;
100  }
101
102 private:
103  // Overridden from views::MenuListener:
104  virtual void OnMenuOpened() OVERRIDE {
105    menu_open_count_++;
106    if (!test_dismiss_menu_) {
107      toolbar_view_->RemoveMenuListener(this);
108      // Press DOWN to select the first item, then RETURN to select it.
109      SendKeyPress(browser_, ui::VKEY_DOWN);
110      SendKeyPress(browser_, ui::VKEY_RETURN);
111    } else {
112      SendKeyPress(browser_, ui::VKEY_ESCAPE);
113      base::MessageLoop::current()->PostDelayedTask(
114          FROM_HERE,
115          base::MessageLoop::QuitClosure(),
116          base::TimeDelta::FromMilliseconds(200));
117    }
118  }
119
120  ToolbarView* toolbar_view_;
121  Browser* browser_;
122  // Keeps track of the number of times the menu was opened.
123  int menu_open_count_;
124  // If this is set then on receiving a notification that the menu was opened
125  // we dismiss it by sending the ESC key.
126  bool test_dismiss_menu_;
127
128  DISALLOW_COPY_AND_ASSIGN(SendKeysMenuListener);
129};
130
131class KeyboardAccessTest : public InProcessBrowserTest {
132 public:
133  KeyboardAccessTest() {}
134
135  // Use the keyboard to select "New Tab" from the app menu.
136  // This test depends on the fact that there is one menu and that
137  // New Tab is the first item in the menu. If the menus change,
138  // this test will need to be changed to reflect that.
139  //
140  // If alternate_key_sequence is true, use "Alt" instead of "F10" to
141  // open the menu bar, and "Down" instead of "Enter" to open a menu.
142  // If focus_omnibox is true then the test on startup sets focus to the
143  // omnibox.
144  void TestMenuKeyboardAccess(bool alternate_key_sequence,
145                              bool shift,
146                              bool focus_omnibox);
147
148  int GetFocusedViewID() {
149    gfx::NativeWindow window = browser()->window()->GetNativeWindow();
150    views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
151    const views::FocusManager* focus_manager = widget->GetFocusManager();
152    const views::View* focused_view = focus_manager->GetFocusedView();
153    return focused_view ? focused_view->id() : -1;
154  }
155
156  void WaitForFocusedViewIDToChange(int original_view_id) {
157    if (GetFocusedViewID() != original_view_id)
158      return;
159    gfx::NativeWindow window = browser()->window()->GetNativeWindow();
160    views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
161    views::FocusManager* focus_manager = widget->GetFocusManager();
162    ViewFocusChangeWaiter waiter(focus_manager, original_view_id);
163    waiter.Wait();
164  }
165
166#if defined(OS_WIN)
167  // Opens the system menu on Windows with the Alt Space combination and selects
168  // the New Tab option from the menu.
169  void TestSystemMenuWithKeyboard();
170#endif
171
172  // Uses the keyboard to select the wrench menu i.e. with the F10 key.
173  // It verifies that the menu when dismissed by sending the ESC key it does
174  // not display twice.
175  void TestMenuKeyboardAccessAndDismiss();
176
177  DISALLOW_COPY_AND_ASSIGN(KeyboardAccessTest);
178};
179
180void KeyboardAccessTest::TestMenuKeyboardAccess(bool alternate_key_sequence,
181                                                bool shift,
182                                                bool focus_omnibox) {
183  // Navigate to a page in the first tab, which makes sure that focus is
184  // set to the browser window.
185  ui_test_utils::NavigateToURL(browser(), GURL("about:"));
186
187  // The initial tab index should be 0.
188  ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
189
190  ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
191
192  // Get the focused view ID, then press a key to activate the
193  // page menu, then wait until the focused view changes.
194  int original_view_id = GetFocusedViewID();
195
196  content::WindowedNotificationObserver new_tab_observer(
197      chrome::NOTIFICATION_TAB_ADDED,
198      content::Source<content::WebContentsDelegate>(browser()));
199
200  BrowserView* browser_view = reinterpret_cast<BrowserView*>(
201      browser()->window());
202  ToolbarView* toolbar_view = browser_view->GetToolbarView();
203  SendKeysMenuListener menu_listener(toolbar_view, browser(), false);
204
205  if (focus_omnibox)
206    browser()->window()->GetLocationBar()->FocusLocation(false);
207
208#if defined(OS_CHROMEOS)
209  // Chrome OS doesn't have a way to just focus the wrench menu, so we use Alt+F
210  // to bring up the menu.
211  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
212      browser(), ui::VKEY_F, false, shift, true, false));
213#else
214  ui::KeyboardCode menu_key =
215      alternate_key_sequence ? ui::VKEY_MENU : ui::VKEY_F10;
216  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
217      browser(), menu_key, false, shift, false, false));
218#endif
219
220  if (shift) {
221    // Verify Chrome does not move the view focus. We should not move the view
222    // focus when typing a menu key with modifier keys, such as shift keys or
223    // control keys.
224    int new_view_id = GetFocusedViewID();
225    ASSERT_EQ(original_view_id, new_view_id);
226    return;
227  }
228
229  WaitForFocusedViewIDToChange(original_view_id);
230
231  // See above comment. Since we already brought up the menu, no need to do this
232  // on ChromeOS.
233#if !defined(OS_CHROMEOS)
234  if (alternate_key_sequence)
235    SendKeyPress(browser(), ui::VKEY_DOWN);
236  else
237    SendKeyPress(browser(), ui::VKEY_RETURN);
238#endif
239
240  // Wait for the new tab to appear.
241  new_tab_observer.Wait();
242
243  // Make sure that the new tab index is 1.
244  ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
245}
246
247#if defined(OS_WIN)
248
249// This CBT hook is set for the duration of the TestSystemMenuWithKeyboard test
250LRESULT CALLBACK SystemMenuTestCBTHook(int n_code,
251                                       WPARAM w_param,
252                                       LPARAM l_param) {
253  // Look for the system menu window getting created or becoming visible and
254  // then select the New Tab option from the menu.
255  if (n_code == HCBT_ACTIVATE || n_code == HCBT_CREATEWND) {
256    wchar_t class_name[MAX_PATH] = {0};
257    GetClassName(reinterpret_cast<HWND>(w_param),
258                 class_name,
259                 arraysize(class_name));
260    if (LowerCaseEqualsASCII(class_name, "#32768")) {
261      // Select the New Tab option and then send the enter key to execute it.
262      ::PostMessage(reinterpret_cast<HWND>(w_param), WM_CHAR, 'T', 0);
263      ::PostMessage(reinterpret_cast<HWND>(w_param), WM_KEYDOWN, VK_RETURN, 0);
264      ::PostMessage(reinterpret_cast<HWND>(w_param), WM_KEYUP, VK_RETURN, 0);
265    }
266  }
267  return ::CallNextHookEx(0, n_code, w_param, l_param);
268}
269
270void KeyboardAccessTest::TestSystemMenuWithKeyboard() {
271  // Navigate to a page in the first tab, which makes sure that focus is
272  // set to the browser window.
273  ui_test_utils::NavigateToURL(browser(), GURL("about:"));
274
275  ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
276
277  content::WindowedNotificationObserver new_tab_observer(
278      chrome::NOTIFICATION_TAB_ADDED,
279      content::Source<content::WebContentsDelegate>(browser()));
280  // Sending the Alt space keys to the browser will bring up the system menu
281  // which runs a model loop. We set a CBT hook to look for the menu and send
282  // keystrokes to it.
283  HHOOK cbt_hook = ::SetWindowsHookEx(WH_CBT,
284                                      SystemMenuTestCBTHook,
285                                      NULL,
286                                      ::GetCurrentThreadId());
287  ASSERT_TRUE(cbt_hook != NULL);
288
289  bool ret = ui_test_utils::SendKeyPressSync(
290      browser(), ui::VKEY_SPACE, false, false, true, false);
291  EXPECT_TRUE(ret);
292
293  if (ret) {
294    // Wait for the new tab to appear.
295    new_tab_observer.Wait();
296    // Make sure that the new tab index is 1.
297    ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
298  }
299  ::UnhookWindowsHookEx(cbt_hook);
300}
301#endif
302
303void KeyboardAccessTest::TestMenuKeyboardAccessAndDismiss() {
304  ui_test_utils::NavigateToURL(browser(), GURL("about:"));
305
306  ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
307
308  ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
309
310  int original_view_id = GetFocusedViewID();
311
312  BrowserView* browser_view = reinterpret_cast<BrowserView*>(
313      browser()->window());
314  ToolbarView* toolbar_view = browser_view->GetToolbarView();
315  SendKeysMenuListener menu_listener(toolbar_view, browser(), true);
316
317  browser()->window()->GetLocationBar()->FocusLocation(false);
318
319  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
320      browser(), ui::VKEY_F10, false, false, false, false));
321
322  WaitForFocusedViewIDToChange(original_view_id);
323
324  SendKeyPress(browser(), ui::VKEY_DOWN);
325  content::RunMessageLoop();
326  ASSERT_EQ(1, menu_listener.menu_open_count());
327}
328
329// http://crbug.com/62310.
330#if defined(OS_CHROMEOS)
331#define MAYBE_TestMenuKeyboardAccess DISABLED_TestMenuKeyboardAccess
332#else
333#define MAYBE_TestMenuKeyboardAccess TestMenuKeyboardAccess
334#endif
335
336IN_PROC_BROWSER_TEST_F(KeyboardAccessTest, MAYBE_TestMenuKeyboardAccess) {
337  TestMenuKeyboardAccess(false, false, false);
338}
339
340// http://crbug.com/62310.
341#if defined(OS_CHROMEOS)
342#define MAYBE_TestAltMenuKeyboardAccess DISABLED_TestAltMenuKeyboardAccess
343#else
344#define MAYBE_TestAltMenuKeyboardAccess TestAltMenuKeyboardAccess
345#endif
346
347IN_PROC_BROWSER_TEST_F(KeyboardAccessTest, MAYBE_TestAltMenuKeyboardAccess) {
348  TestMenuKeyboardAccess(true, false, false);
349}
350
351// If this flakes, use http://crbug.com/62311.
352#if defined(OS_WIN)
353#define MAYBE_TestShiftAltMenuKeyboardAccess DISABLED_TestShiftAltMenuKeyboardAccess
354#else
355#define MAYBE_TestShiftAltMenuKeyboardAccess TestShiftAltMenuKeyboardAccess
356#endif
357IN_PROC_BROWSER_TEST_F(KeyboardAccessTest,
358                       MAYBE_TestShiftAltMenuKeyboardAccess) {
359  TestMenuKeyboardAccess(true, true, false);
360}
361
362#if defined(OS_WIN)
363IN_PROC_BROWSER_TEST_F(KeyboardAccessTest,
364                       DISABLED_TestAltMenuKeyboardAccessFocusOmnibox) {
365  TestMenuKeyboardAccess(true, false, true);
366}
367
368IN_PROC_BROWSER_TEST_F(KeyboardAccessTest,
369                       DISABLED_TestSystemMenuWithKeyboard) {
370  TestSystemMenuWithKeyboard();
371}
372#endif
373
374#if !defined(OS_WIN) && defined(USE_AURA) && !defined(USE_OZONE)
375// ozone bringup - http://crbug.com/401304
376IN_PROC_BROWSER_TEST_F(KeyboardAccessTest, TestMenuKeyboardOpenDismiss) {
377  TestMenuKeyboardAccessAndDismiss();
378}
379#endif
380
381// Test that JavaScript cannot intercept reserved keyboard accelerators like
382// ctrl-t to open a new tab or ctrl-f4 to close a tab.
383// TODO(isherman): This test times out on ChromeOS.  We should merge it with
384// BrowserKeyEventsTest.ReservedAccelerators, but just disable for now.
385// If this flakes, use http://crbug.com/62311.
386IN_PROC_BROWSER_TEST_F(KeyboardAccessTest, ReserveKeyboardAccelerators) {
387  const std::string kBadPage =
388      "<html><script>"
389      "document.onkeydown = function() {"
390      "  event.preventDefault();"
391      "  return false;"
392      "}"
393      "</script></html>";
394  GURL url("data:text/html," + kBadPage);
395  ui_test_utils::NavigateToURLWithDisposition(
396      browser(), url, NEW_FOREGROUND_TAB,
397      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
398
399  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
400      browser(), ui::VKEY_TAB, true, false, false, false));
401  ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
402
403  ui_test_utils::NavigateToURLWithDisposition(
404      browser(), url, NEW_FOREGROUND_TAB,
405      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
406  ASSERT_EQ(2, browser()->tab_strip_model()->active_index());
407
408  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
409      browser(), ui::VKEY_W, true, false, false, false));
410  ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
411}
412
413#if defined(OS_WIN)  // These keys are Windows-only.
414IN_PROC_BROWSER_TEST_F(KeyboardAccessTest, BackForwardKeys) {
415  // Navigate to create some history.
416  ui_test_utils::NavigateToURL(browser(), GURL("chrome://version/"));
417  ui_test_utils::NavigateToURL(browser(), GURL("chrome://about/"));
418
419  base::string16 before_back;
420  ASSERT_TRUE(ui_test_utils::GetCurrentTabTitle(browser(), &before_back));
421
422  // Navigate back.
423  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
424      browser(), ui::VKEY_BROWSER_BACK, false, false, false, false));
425
426  base::string16 after_back;
427  ASSERT_TRUE(ui_test_utils::GetCurrentTabTitle(browser(), &after_back));
428
429  EXPECT_NE(before_back, after_back);
430
431  // And then forward.
432  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
433      browser(), ui::VKEY_BROWSER_FORWARD, false, false, false, false));
434
435  base::string16 after_forward;
436  ASSERT_TRUE(ui_test_utils::GetCurrentTabTitle(browser(), &after_forward));
437
438  EXPECT_EQ(before_back, after_forward);
439}
440#endif
441
442}  // namespace
443