chrome/browser/ui/webui/options/language_dictionary_interactive_uitest.cc

   1 // Copyright 2015 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 "base/strings/stringprintf.h"
   6 #include "chrome/browser/chrome_notification_types.h"
   7 #include "chrome/browser/ui/browser_window.h"
   8 #include "chrome/browser/ui/chrome_pages.h"
   9 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  10 #include "chrome/common/url_constants.h"
  11 #include "chrome/test/base/in_process_browser_test.h"
  12 #include "chrome/test/base/interactive_test_utils.h"
  13 #include "content/public/test/browser_test_utils.h"
  14
  15 namespace {
  16
  17 // This class tests the language dictionary settings.
  18 // This test is part of the interactive_ui_tests instead of browser_tests
  19 // because it is necessary to emulate pushing the tab key.
  20 class LanguageDictionaryWebUITest : public InProcessBrowserTest {
  21  public:
  22   LanguageDictionaryWebUITest() {}
  23
  24   // Navigate to the editDictionary page.
  25   void SetUpOnMainThread() override {
  26     const GURL url = chrome::GetSettingsUrl("editDictionary");
  27     ui_test_utils::NavigateToURL(browser(), url);
  28   }
  29
  30  protected:
  31   const std::string kDictionaryListSelector =
  32       "#language-dictionary-overlay-word-list";
  33
  34   content::RenderFrameHost* GetActiveFrame() {
  35     return GetActiveWebContents()->GetFocusedFrame();
  36   }
  37
  38   content::RenderViewHost* GetRenderViewHost() {
  39     return GetActiveWebContents()->GetRenderViewHost();
  40   }
  41
  42   content::WebContents* GetActiveWebContents() {
  43     return browser()->tab_strip_model()->GetActiveWebContents();
  44   }
  45
  46   // Add a few test words to the dictionary.
  47   void SetTestWords(const std::string& list_selector) {
  48     const std::string script = base::StringPrintf(
  49         "document.querySelector('%s').setWordList(['cat', 'dog', 'bird']);",
  50         list_selector.c_str());
  51     EXPECT_TRUE(content::ExecuteScript(GetActiveFrame(), script));
  52     // Expected list size is 4: 3 word items + 1 placeholder.
  53     EXPECT_EQ(4, GetListSize(list_selector));
  54   }
  55
  56   // Returns the number of items in the list.
  57   int GetListSize(const std::string& list_selector) {
  58     const std::string script = base::StringPrintf(
  59         "domAutomationController.send("
  60         "document.querySelector('%s').items.length);",
  61         list_selector.c_str());
  62     int length = -1;
  63     EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
  64         GetActiveFrame(),
  65         script,
  66         &length));
  67     return length;
  68   }
  69
  70   // Returns true if element contains document.activeElement.
  71   bool ContainsActiveElement(const std::string& element_selector) {
  72     const std::string script = base::StringPrintf(
  73         "domAutomationController.send("
  74         "document.querySelector('%s').contains(document.activeElement));",
  75         element_selector.c_str());
  76     bool result;
  77     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
  78         GetActiveFrame(),
  79         script,
  80         &result));
  81     return result;
  82   }
  83
  84   // Returns true if list item[|index|] contains document.activeElement.
  85   bool ListItemContainsActiveElement(const std::string& list_selector,
  86                                      int index) {
  87     EXPECT_GE(index, 0);
  88     // EXPECT_TRUE will fail if index is out of bounds.
  89     const std::string script = base::StringPrintf(
  90         "domAutomationController.send("
  91         "document.querySelector('%s').items[%d].contains("
  92         "document.activeElement));",
  93         list_selector.c_str(),
  94         index);
  95     bool result;
  96     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
  97         GetActiveFrame(),
  98         script,
  99         &result));
 100     return result;
 101   }
 102
 103   // Returns true if list item[|index|] has 'selected' attribute.
 104   bool ListItemSelected(const std::string& list_selector, int index) {
 105     EXPECT_GE(index, 0);
 106     // EXPECT_TRUE will fail if index is out of bounds.
 107     const std::string script = base::StringPrintf(
 108         "domAutomationController.send("
 109         "document.querySelector('%s').items[%d].hasAttribute('selected'));",
 110         list_selector.c_str(),
 111         index);
 112     bool result = false;
 113     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
 114         GetActiveFrame(),
 115         script,
 116         &result));
 117     return result;
 118   }
 119
 120   // Returns true if list item[|index|] has 'selected' attribute and contains
 121   // document.activeElement.
 122   bool ListItemSelectedAndFocused(const std::string& list_selector,
 123                                   int index) {
 124     EXPECT_GE(index, 0);
 125     return ListItemSelected(list_selector, index) &&
 126            ListItemContainsActiveElement(list_selector, index);
 127   }
 128
 129   // Press and release a key in the browser. This will wait for the element on
 130   // the page to change.
 131   bool PressKey(ui::KeyboardCode key_code, bool shift) {
 132     return ui_test_utils::SendKeyPressAndWait(
 133         browser(),
 134         key_code,
 135         false,
 136         shift,
 137         false,
 138         false,
 139         content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
 140         content::Source<content::RenderViewHost>(GetRenderViewHost()));
 141   }
 142
 143   void InitializeDomMessageQueue() {
 144     dom_message_queue_.reset(new content::DOMMessageQueue);
 145   }
 146
 147   // Wait for a message from the DOM automation controller.
 148   void WaitForDomMessage(const std::string& message) {
 149     const std::string expected = "\"" + message + "\"";
 150     std::string received;
 151     do {
 152       ASSERT_TRUE(dom_message_queue_->WaitForMessage(&received));
 153     } while (received != expected);
 154   }
 155
 156   // Add a JavaScript event listener to send a DOM automation controller message
 157   // whenever the |selected| property of the list item changes.
 158   void ListenForItemSelectedChange(const std::string& list_selector,
 159                                    int index) {
 160     EXPECT_GE(index, 0);
 161     // EXPECT_TRUE will fail if index is out of bounds.
 162     const std::string script = base::StringPrintf(
 163         "document.querySelector('%s').items[%d].addEventListener("
 164             "'selectedChange', function() {"
 165               "domAutomationController.setAutomationId(0);"
 166               "domAutomationController.send('selected=' + this.selected);"
 167             "});",
 168         list_selector.c_str(),
 169         index);
 170
 171     EXPECT_TRUE(content::ExecuteScript(
 172         GetActiveFrame(),
 173         script));
 174   }
 175
 176  private:
 177   scoped_ptr<content::DOMMessageQueue> dom_message_queue_;
 178
 179   DISALLOW_COPY_AND_ASSIGN(LanguageDictionaryWebUITest);
 180 };
 181
 182 }  // namespace
 183
 184 // Test InlineEditableItemList keyboard focus behavior in editDictionary
 185 // overlay.
 186 // editDictionary overlay doesn't exist on OSX so disable it there.
 187 #if !defined(OS_MACOSX)
 188 IN_PROC_BROWSER_TEST_F(LanguageDictionaryWebUITest,
 189                        TestListKeyboardFocus) {
 190   const std::string list_selector = kDictionaryListSelector;
 191
 192   // Populate the list with some test words.
 193   SetTestWords(list_selector);
 194   int placeholder_index = GetListSize(list_selector) - 1;
 195
 196   // Listen for changes of the placeholder item's |selected| property so that
 197   // test can wait until change has taken place after key press before
 198   // continuing.
 199   InitializeDomMessageQueue();
 200   ListenForItemSelectedChange(list_selector, placeholder_index);
 201
 202   // Press tab to focus the placeholder.
 203   PressKey(ui::VKEY_TAB, false);
 204
 205   // Wait for placeholder item to become selected.
 206   WaitForDomMessage("selected=true");
 207
 208   // Verify that the placeholder is selected and has focus.
 209   EXPECT_TRUE(ListItemSelectedAndFocused(list_selector, placeholder_index));
 210
 211   // Press up arrow to select item above the placeholder.
 212   PressKey(ui::VKEY_UP, false);
 213
 214   // Wait for placeholder to become unselected.
 215   WaitForDomMessage("selected=false");
 216
 217   // Verify that the placeholder is no longer selected.
 218   EXPECT_FALSE(ListItemSelected(list_selector, placeholder_index));
 219
 220   // Verify that the item above the placeholder is selected and has focus.
 221   EXPECT_TRUE(ListItemSelectedAndFocused(list_selector,
 222                                          placeholder_index - 1));
 223
 224   // Press tab to leave the list.
 225   PressKey(ui::VKEY_TAB, false);
 226
 227   // Verify that focus has left the list.
 228   EXPECT_FALSE(ContainsActiveElement(list_selector));
 229
 230   // Verify that the item above the placeholder is still selected.
 231   EXPECT_TRUE(ListItemSelected(list_selector, placeholder_index - 1));
 232
 233   // Press shift+tab to go back to the list.
 234   PressKey(ui::VKEY_TAB, true);
 235
 236   // Verify that the item above the placeholder is selected and has focus.
 237   EXPECT_TRUE(ListItemSelectedAndFocused(list_selector,
 238                                          placeholder_index - 1));
 239 }
 240 #endif  // !defined(OS_MACOSX)