Add BrowserCommandController Interactive Test

chrome/browser/ui/browser_command_controller_interactive_browsertest.cc

Index: chrome/browser/ui/browser_command_controller_interactive_browsertest.cc
diff --git a/chrome/browser/ui/browser_command_controller_interactive_browsertest.cc b/chrome/browser/ui/browser_command_controller_interactive_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..66abc8c7bed324eb68d34b5bb37358b75916c707
--- /dev/null
+++ b/chrome/browser/ui/browser_command_controller_interactive_browsertest.cc
@@ -0,0 +1,343 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/string_util.h"
+#include "build/build_config.h"
+#include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/interactive_test_utils.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_utils.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/keycodes/keyboard_code_conversion.h"
+#include "ui/events/keycodes/keyboard_codes.h"
+#include "url/gurl.h"
+
+#if defined(OS_MACOSX)
+#include "base/mac/mac_util.h"
+#endif
+
+namespace {
+// The html file to receive key events, prevent defaults and export all the
+// events with "getKeyEventReport()" function. It has two magic keys: pressing
+// "S" to enter fullscreen mode; pressing "X" to indicate the end of all the
+// keys.
+constexpr char kFullscreenKeyboardLockHTML[] = "/fullscreen_keyboardlock.html";
+
+// On MacOSX command key is used for most of the shortcuts, so replace it with
+// control to reduce the complexity of comparison of the results.
+void NormalizeMetaKeyForMacOS(std::string* output) {
+#if defined(OS_MACOSX)
+  base::ReplaceSubstringsAfterOffset(output, 0, "MetaLeft", "ControlLeft");
+#else
+  // Avoid unused variable warning.
+  output = nullptr;
+#endif
+}
+
+}  // namespace
+
+class BrowserCommandControllerInteractiveTest : public InProcessBrowserTest {
+ public:
+  BrowserCommandControllerInteractiveTest() = default;
+  ~BrowserCommandControllerInteractiveTest() override = default;
+
+ protected:
+  // Starts the test page and waits for it to be loaded.
+  void StartTestPage();
+
+  // Wait for the browser to have the expected tab count or timeout.
+  void WaitForTabCount(int tab_count) const;
+
+  // Sends a control or command + |key| shortcut to the focused window. Shift
+  // modifier will be added if |shift| is true.
+  void SendShortcut(ui::KeyboardCode key, bool shift = false);
+
+  // Sends a control or command + shift + |key| shortcut to the focused window.
+  void SendShiftShortcut(ui::KeyboardCode key);
+
+  // Sends a fullscreen shortcut to the focused window and wait for the
+  // operation to take effect.
+  void SendFullscreenShortcutAndWait();
+
+  // Sends a KeyS to the focused window to trigger JavaScript fullscreen and
+  // wait for the operation to take effect.
+  void SendJsFullscreenShortcutAndWait();
+
+  // Sends an ESC to the focused window.
+  void SendEscape();
+
+  // Sends an ESC to the focused window to exit JavaScript fullscreen and wait
+  // for the operation to take effect.
+  void SendEscapeAndWaitForExitingFullscreen();
+
+  // Sends a set of preventable shortcuts to the web page.
+  void SendShortcutsInFullscreen();
+
+  // Sends a magic KeyX to the focused window to stop the test case, receives
+  // the result and verifies if it is equal to |expected_result_|.
+  void FinishTestAndVerifyResult();
+
+ private:
+  void SetUpOnMainThread() override;
+
+  std::string expected_result_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserCommandControllerInteractiveTest);
+};
+
+void BrowserCommandControllerInteractiveTest::StartTestPage() {
+  ASSERT_TRUE(embedded_test_server()->Start());
+  // Ensures the initial states.
+  ASSERT_EQ(1, browser()->tab_strip_model()->count());
+  ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
+  ASSERT_EQ(1U, BrowserList::GetInstance()->size());
+  // Add a second tab for counting and focus purposes.
+  AddTabAtIndex(1, GURL("about:blank"), ui::PAGE_TRANSITION_LINK);

[Paweł Hajdan Jr., 2017/07/11 11:59:57]

nit: Use url::kAboutBlankURL .

[Hzj_jie, 2017/07/11 17:47:26]

Done.

+  ASSERT_EQ(2, browser()->tab_strip_model()->count());
+  ASSERT_EQ(1U, BrowserList::GetInstance()->size());
+
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), embedded_test_server()->GetURL(kFullscreenKeyboardLockHTML),
+      WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+}
+
+void BrowserCommandControllerInteractiveTest::WaitForTabCount(
+    int tab_count) const {
+  while (browser()->tab_strip_model()->count() != tab_count)

[Paweł Hajdan Jr., 2017/07/11 11:59:57]

Loops like this make me suspicious. Can we wait for an event instead?

[Hzj_jie, 2017/07/11 17:47:26]

In an early iteration, a TabCountObserver has been added
(https://codereview.chromium.org/2922773002/diff/650001/chrome/browser/ui/brow...).
It's much more complex than the while-loop, but internally they do exactly the
same thing to loop until condition meets.
Mike suggested to remove the observer and use the while-loop directly instead.

+    content::RunAllPendingInMessageLoop();
+}
+
+void BrowserCommandControllerInteractiveTest::SendShortcut(
+    ui::KeyboardCode key,
+    bool shift /* = false */) {
+#if defined(OS_MACOSX)
+  const bool control_modifier = false;
+  const bool command_modifier = true;
+#else
+  const bool control_modifier = true;
+  const bool command_modifier = false;
+#endif
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), key, control_modifier,
+                                              shift, false, command_modifier));
+
+  expected_result_ += ui::KeycodeConverter::DomCodeToCodeString(
+      ui::UsLayoutKeyboardCodeToDomCode(key));
+  expected_result_ += " ctrl:";
+  expected_result_ += control_modifier ? "true" : "false";
+  expected_result_ += " shift:";
+  expected_result_ += shift ? "true" : "false";
+  expected_result_ += " alt:false";
+  expected_result_ += " meta:";
+  expected_result_ += command_modifier ? "true" : "false";
+  expected_result_ += '\n';
+}
+
+void BrowserCommandControllerInteractiveTest::SendShiftShortcut(
+    ui::KeyboardCode key) {
+  SendShortcut(key, true);
+}
+
+void BrowserCommandControllerInteractiveTest::SendFullscreenShortcutAndWait() {
+  content::WindowedNotificationObserver observer(
+      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+      content::NotificationService::AllSources());
+// Enter fullscreen.
+#if defined(OS_MACOSX)
+  // On MACOSX, Command + Control + F is used.
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_F, true,
+                                              false, false, true));
+#elif defined(OS_CHROMEOS)
+  // A dedicated fullscreen key is used on Chrome OS, so send a fullscreen
+  // command directly instead, to avoid constructing the key press.
+  ASSERT_TRUE(chrome::ExecuteCommand(browser(), IDC_FULLSCREEN));
+#else
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_F11, false,
+                                              false, false, false));
+#endif
+
+  observer.Wait();
+}
+
+void BrowserCommandControllerInteractiveTest::
+    SendJsFullscreenShortcutAndWait() {
+  content::WindowedNotificationObserver observer(
+      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+      content::NotificationService::AllSources());
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_S, false,
+                                              false, false, false));
+  expected_result_ += "KeyS ctrl:false shift:false alt:false meta:false\n";
+  observer.Wait();
+}
+
+void BrowserCommandControllerInteractiveTest::SendEscape() {
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_ESCAPE, false,
+                                              false, false, false));
+  expected_result_ += "Escape ctrl:false shift:false alt:false meta:false\n";
+}
+
+void BrowserCommandControllerInteractiveTest ::
+    SendEscapeAndWaitForExitingFullscreen() {
+  content::WindowedNotificationObserver observer(
+      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+      content::NotificationService::AllSources());
+  ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_ESCAPE, false,
+                                              false, false, false));
+  observer.Wait();
+}
+
+void BrowserCommandControllerInteractiveTest::SendShortcutsInFullscreen() {
+  const int initial_active_index = browser()->tab_strip_model()->active_index();
+  const int initial_tab_count = browser()->tab_strip_model()->count();
+  const size_t initial_browser_count = BrowserList::GetInstance()->size();
+  // The tab should not be closed.
+  SendShortcut(ui::VKEY_W);
+  ASSERT_EQ(initial_tab_count, browser()->tab_strip_model()->count());
+  // The window should not be closed.
+  SendShiftShortcut(ui::VKEY_W);
+  ASSERT_EQ(initial_browser_count, BrowserList::GetInstance()->size());
+// TODO(zijiehe): ChromeOS incorrectly handles these;
+// see http://crbug.com/737307.
+#if !defined(OS_CHROMEOS)
+  // A new tab should not be created.
+  SendShortcut(ui::VKEY_T);
+  ASSERT_EQ(initial_tab_count, browser()->tab_strip_model()->count());
+  // A new window should not be created.
+  SendShortcut(ui::VKEY_N);
+  ASSERT_EQ(initial_browser_count, BrowserList::GetInstance()->size());
+  // A new incognito window should not be created.
+  SendShiftShortcut(ui::VKEY_N);
+  ASSERT_EQ(initial_browser_count, BrowserList::GetInstance()->size());
+  // Last closed tab should not be restored.
+  SendShiftShortcut(ui::VKEY_T);
+  ASSERT_EQ(initial_tab_count, browser()->tab_strip_model()->count());
+#endif
+  // Browser should not switch to the next tab.
+  SendShortcut(ui::VKEY_TAB);
+  ASSERT_EQ(initial_active_index, browser()->tab_strip_model()->active_index());
+  // Browser should not switch to the previous tab.
+  SendShiftShortcut(ui::VKEY_TAB);
+  ASSERT_EQ(initial_active_index, browser()->tab_strip_model()->active_index());
+}
+
+void BrowserCommandControllerInteractiveTest::FinishTestAndVerifyResult() {
+  // Magic KeyX to stop the test.
+  EXPECT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_X, false,
+                                              false, false, false));
+  expected_result_ += "KeyX ctrl:false shift:false alt:false meta:false";
+  std::string result;
+  EXPECT_TRUE(content::ExecuteScriptAndExtractString(
+      browser()->tab_strip_model()->GetActiveWebContents()->GetRenderViewHost(),
+      "getKeyEventReport();", &result));
+  NormalizeMetaKeyForMacOS(&result);
+  NormalizeMetaKeyForMacOS(&expected_result_);
+  base::TrimWhitespaceASCII(result, base::TRIM_ALL, &result);
+  ASSERT_EQ(expected_result_, result);
+}
+
+void BrowserCommandControllerInteractiveTest::SetUpOnMainThread() {
+  ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+}
+
+IN_PROC_BROWSER_TEST_F(BrowserCommandControllerInteractiveTest,
+                       ShortcutsShouldTakeEffectInWindowMode) {
+  ASSERT_EQ(1, browser()->tab_strip_model()->count());
+  SendShortcut(ui::VKEY_T);
+  WaitForTabCount(2);
+  ASSERT_EQ(2, browser()->tab_strip_model()->count());
+  SendShortcut(ui::VKEY_T);
+  WaitForTabCount(3);
+  ASSERT_EQ(3, browser()->tab_strip_model()->count());
+  SendShortcut(ui::VKEY_W);
+  WaitForTabCount(2);
+  ASSERT_EQ(2, browser()->tab_strip_model()->count());
+  SendShortcut(ui::VKEY_W);
+  WaitForTabCount(1);
+  ASSERT_EQ(1, browser()->tab_strip_model()->count());
+  SendFullscreenShortcutAndWait();
+  ASSERT_TRUE(browser()
+                  ->exclusive_access_manager()
+                  ->fullscreen_controller()
+                  ->IsFullscreenForBrowser());
+}
+
+IN_PROC_BROWSER_TEST_F(BrowserCommandControllerInteractiveTest,
+                       UnpreservedShortcutsShouldBePreventable) {
+  StartTestPage();
+
+  // The browser print function should be blocked by the web page.
+  SendShortcut(ui::VKEY_P);
+  // The system print function should be blocked by the web page.
+  SendShiftShortcut(ui::VKEY_P);
+  FinishTestAndVerifyResult();
+}
+
+#if defined(OS_MACOSX)
+// TODO(zijiehe): Figure out why this test crashes on Mac OSX. The suspicious
+// command is "SendFullscreenShortcutAndWait()". See, http://crbug.com/738949.
+#define MAYBE_KeyEventsShouldBeConsumedByWebPageInBrowserFullscreen \
+  DISABLED_KeyEventsShouldBeConsumedByWebPageInBrowserFullscreen
+#else
+#define MAYBE_KeyEventsShouldBeConsumedByWebPageInBrowserFullscreen \
+  KeyEventsShouldBeConsumedByWebPageInBrowserFullscreen
+#endif
+IN_PROC_BROWSER_TEST_F(
+    BrowserCommandControllerInteractiveTest,
+    MAYBE_KeyEventsShouldBeConsumedByWebPageInBrowserFullscreen) {
+  StartTestPage();
+
+  SendFullscreenShortcutAndWait();
+  SendShortcutsInFullscreen();
+  // Current page should not exit browser fullscreen mode.
+  SendEscape();
+
+  FinishTestAndVerifyResult();
+}
+
+IN_PROC_BROWSER_TEST_F(
+    BrowserCommandControllerInteractiveTest,
+    KeyEventsShouldBeConsumedByWebPageInJsFullscreenExceptForEsc) {
+  StartTestPage();
+
+  SendJsFullscreenShortcutAndWait();
+  SendShortcutsInFullscreen();
+  // Current page should exit HTML fullscreen mode.
+  SendEscapeAndWaitForExitingFullscreen();
+
+  FinishTestAndVerifyResult();
+}
+
+IN_PROC_BROWSER_TEST_F(
+    BrowserCommandControllerInteractiveTest,
+    KeyEventsShouldBeConsumedByWebPageInJsFullscreenExceptForF11) {
+  StartTestPage();
+
+  SendJsFullscreenShortcutAndWait();
+  SendShortcutsInFullscreen();
+#if defined(OS_MACOSX)
+  // On 10.9 or earlier, sending the exit fullscreen shortcut will crash the
+  // binary. See http://crbug.com/740250.
+  if (base::mac::IsAtLeastOS10_10()) {
+    // Current page should exit browser fullscreen mode.
+    SendFullscreenShortcutAndWait();
+  }
+#else
+  // Current page should exit browser fullscreen mode.
+  SendFullscreenShortcutAndWait();
+#endif
+
+  FinishTestAndVerifyResult();
+}