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..ed67c459a78dd54ba118ee4b4a158f92d47f1328
--- /dev/null
+++ b/chrome/browser/ui/browser_command_controller_interactive_browsertest.cc
@@ -0,0 +1,344 @@
+// 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"
+#include "url/url_constants.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;

[sky, 2017/07/13 20:33:25]

Are you sure this is really necessary?

[Hzj_jie, 2017/07/13 23:05:11]

My fault, removed.

+#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_;

[sky, 2017/07/13 20:33:25]

Please add a comment.

[Hzj_jie, 2017/07/13 23:05:11]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(BrowserCommandControllerInteractiveTest);
+};
+
+void BrowserCommandControllerInteractiveTest::StartTestPage() {

[sky, 2017/07/13 20:33:25]

You need to wrap all calls to this in ASSERT_NO_FATAL_FAILURE, otherwise tests
continue execution even if the assertions in this function fail.

[Hzj_jie, 2017/07/13 23:05:11]

Done.

+  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(url::kAboutBlankURL), ui::PAGE_TRANSITION_LINK);
+  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(

[sky, 2017/07/13 20:33:26]

Why do you need the wait here? AFAICT you wait for the key events to be
processed synchronously, so shouldn't the tab count already have changed?
Assuming you do need to wait, use a TabStripModelObserver to wait for the count
to be what you want.

[Hzj_jie, 2017/07/13 23:05:11]

Done.

+    int tab_count) const {
+  while (browser()->tab_strip_model()->count() != tab_count)
+    content::RunAllPendingInMessageLoop();
+}
+
+void BrowserCommandControllerInteractiveTest::SendShortcut(

[sky, 2017/07/13 20:33:25]

Similar comment about ASSERT_NO_FATAL_FAILURE.

[Hzj_jie, 2017/07/13 23:05:11]

Done.

+    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.

[sky, 2017/07/13 20:33:25]

fix indentation.

[Hzj_jie, 2017/07/13 23:05:11]

It's triple weird, this is done by git cl format. But anyway, I will revert it.

+#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,

[sky, 2017/07/13 20:33:25]

Similar comment here about the need to wait.

[Hzj_jie, 2017/07/13 23:05:11]

At least on Mac OSX, entering and exiting fullscreen are not synchronous.
(https://www.google.com/search?q=toggleFullScreen&oq=toggleFullScreen&aqs=chro...)
https://cs.chromium.org/chromium/src/chrome/browser/ui/cocoa/browser_window_c...

[sky, 2017/07/14 00:03:37]

Ok, please add a comment to that effect then.

[Hzj_jie, 2017/07/14 00:24:51]

Done.

+                                              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;

[sky, 2017/07/13 20:33:26]

fix indentation.

[Hzj_jie, 2017/07/13 23:05:11]

Done.

+// 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,

[sky, 2017/07/13 20:33:25]

Why is this necessary?

[Hzj_jie, 2017/07/13 23:05:11]

If my understanding is correct, the keys are sent to renderer process through
IPC channel. So SendKeyPressSync() is only "synchronous" in browser process, but
not renderer process. Since these keys need to be handled by JS in renderer
process, the KeyX indicates the end of the tests, i.e. test html page can report
the recorded keys to window.domAutomationController.

Without the magic KeyX, the getKeyEventReport() may receive partial key
sequence. This happens at least on Mac OSX.

[sky, 2017/07/14 00:03:37]

Pleaes add a better comment (the current comment is not at all clear).

[Hzj_jie, 2017/07/14 00:24:51]

Done.

+                                              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();
+}