Add support for multiply values in keyboard_layouts to OobeLocalizationTest.

chrome/browser/chromeos/login/oobe_localization_browsertest.cc

 // Copyright 2014 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 "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 73 matching lines @@
 
 }  // namespace system
 
 class OobeLocalizationTest : public InProcessBrowserTest {
  public:
   OobeLocalizationTest();
 
   // Returns true if the expression was successfully executed and returned true.
   bool JsExecute(const std::string& expression);
 
+  // Returns true if the expression was successfully executed.
+  // Stored expression result to 'result'.
+  bool JsExecute(const std::string& expression, std::string* result);
+
   // Verifies that the comma-separated |values| corresponds with the first
   // values in |select_id|, optionally checking for an options group label after
   // the first set of options.
   void VerifyInitialOptions(const char* select_id,
                             const char* values,
                             bool check_separator);
 
   // Verifies that |value| exists in |select_id|.
   void VerifyOptionExists(const char* select_id, const char* value);
 
+  // Dumps OOBE select control (language or keyboard) to string.
+  std::string DumpOptions(const char* select_id);
+
  protected:
   // Runs the test for the given locale and keyboard layout.
   void RunLocalizationTest(const std::string& initial_locale,
                            const std::string& keyboard_layout,
                            const std::string& expected_locale,
-                           const std::string& expected_keyboard_layout);
+                           const std::string& expected_keyboard_layout,
+                           const std::string& expected_keyboard_select_control);
 
  private:
   scoped_ptr<system::FakeStatisticsProvider> statistics_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(OobeLocalizationTest);
 };
 
 OobeLocalizationTest::OobeLocalizationTest() {
   statistics_provider_.reset(new system::FakeStatisticsProvider());
   // Set the instance returned by GetInstance() for testing.
   system::StatisticsProvider::SetTestProvider(statistics_provider_.get());
 }
 
 bool OobeLocalizationTest::JsExecute(const std::string& expression) {
   chromeos::LoginDisplayHostImpl* display_host =
       static_cast<chromeos::LoginDisplayHostImpl*>(
           chromeos::LoginDisplayHostImpl::default_host());
   const std::string js("window.domAutomationController.send(!!(" +
                        expression + "));");
 
   bool result;
   if (content::ExecuteScriptAndExtractBool(
           display_host->GetOobeUI()->web_ui()->GetWebContents(), js, &result))
     return result;
 
   // Execution failed.
   return false;
 }
 
+bool OobeLocalizationTest::JsExecute(const std::string& expression,

[dzhioev (left Google), 2014/02/18 01:37:49]

Don't you want to use JSChecker from
chrome/browser/chromeos/login/test/js_checker.h instead?

[Alexander Alekseev, 2014/02/18 13:38:43]

Done.

+                                     std::string* out) {
+  chromeos::LoginDisplayHostImpl* display_host =
+      static_cast<chromeos::LoginDisplayHostImpl*>(
+          chromeos::LoginDisplayHostImpl::default_host());
+  const std::string js("window.domAutomationController.send(" + expression +
+                       ");");
+
+  return content::ExecuteScriptAndExtractString(
+      display_host->GetOobeUI()->web_ui()->GetWebContents(), js, out);
+}
+
 void OobeLocalizationTest::VerifyInitialOptions(const char* select_id,
                                                 const char* values,
                                                 bool check_separator) {
   const std::string expression = base::StringPrintf(
       "(function () {\n"
       "  var select = document.querySelector('#%s');\n"
       "  if (!select)\n"
       "    return false;\n"
       "  var values = '%s'.split(',');\n"
       "  var correct = select.selectedIndex == 0;\n"
@@ skipping 17 matching lines @@
       "    return false;\n"
       "  for (var i = 0; i < select.options.length; i++) {\n"
       "    if (select.options[i].value == '%s')\n"
       "      return true;\n"
       "  }\n"
       "  return false;\n"
       "})()", select_id, value);
   ASSERT_TRUE(JsExecute(expression)) << expression;
 }
 
+std::string OobeLocalizationTest::DumpOptions(const char* select_id) {
+  const std::string expression = base::StringPrintf(
+      "\n"

[dzhioev (left Google), 2014/02/18 01:37:49]

I think it's better to define method (named dumpOptionsForTesting, for example)
on JS-side, instead of inlining here. This code is hard to read and modify.

[Alexander Alekseev, 2014/02/18 13:38:43]

Discussed offline and decided to leave as it is for now.

+      "(function () {\n"
+      "  var selector = '#%s';\n"
+      "  var divider = ',';\n"
+      "  var select = document.querySelector(selector);\n"
+      "  if (!select)\n"
+      "    throw 'document.querySelector(' + selector + ') failed.';\n"

[michaelpg, 2014/02/17 22:39:10]

If this throws, the test will hang until killed. Can we just return the error
string instead of throwing it?

[Alexander Alekseev, 2014/02/18 13:38:43]

Done.

+      "  var dumpOptgroup = function(group) {\n"
+      "    var result = '';\n"
+      "    for (var i = 0; i < group.children.length; i++) {\n"
+      "      if (i > 0) {\n"
+      "        result += divider;\n"
+      "      }\n"
+      "      if (group.children[i].value) {\n"
+      "        result += group.children[i].value;\n"
+      "      } else {\n"
+      "        result += '__NO_VALUE__';\n"
+      "      }\n"
+      "    }\n"
+      "    return result;\n"
+      "  };\n"
+      "  var result = '';\n"
+      "  var children = select.children;\n"
+      "  for (var i = 0; i < children.length; i++) {\n"
+      "    if (i > 0) {\n"
+      "      result += divider;\n"
+      "    }\n"
+      "    if (children[i].value) {\n"
+      "      result += children[i].value;\n"
+      "    } else if (children[i].tagName === 'OPTGROUP') {\n"
+      "      result += '[' + dumpOptgroup(children[i]) + ']';\n"
+      "    } else {\n"
+      "      result += '__NO_VALUE__';\n"
+      "    }\n"
+      "  }\n"
+      "  return result;\n"
+      "})()\n",
+      select_id);
+  std::string result;
+  if (!JsExecute(expression, &result)) {
+    return std::string("Expression '") + expression + "' failed (result='" +
+           result + "').";
+  }
+  return result;
+}
+
 void OobeLocalizationTest::RunLocalizationTest(
     const std::string& initial_locale,
     const std::string& keyboard_layout,
     const std::string& expected_locale,
-    const std::string& expected_keyboard_layout) {
+    const std::string& expected_keyboard_layout,
+    const std::string& expected_keyboard_select_control) {
   statistics_provider_->set_locale(initial_locale);
   statistics_provider_->set_keyboard_layout(keyboard_layout);
 
   // Initialize StartupCustomizationDocument with fake statistics provider.
   StartupCustomizationDocument::GetInstance()->Init(
       statistics_provider_.get());
 
   // Bring up the OOBE network screen.
   chromeos::ShowLoginWizard(chromeos::WizardController::kNetworkScreenName);
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
   VerifyInitialOptions(kLocaleSelect, expected_locale.c_str(), true);
   VerifyInitialOptions(kKeyboardSelect,
                        expected_keyboard_layout.c_str(),
                        false);
 
   // Make sure we have a fallback keyboard.
   VerifyOptionExists(kKeyboardSelect, kUSLayout);
 
+  // Note, that sort order is locale-specific, but is unlikely to change.
+  // Especially for keyboard layouts.
+  EXPECT_EQ(expected_keyboard_select_control, DumpOptions(kKeyboardSelect));
+
   // Shut down the display host.
   chromeos::LoginDisplayHostImpl::default_host()->Finalize();
   base::MessageLoopForUI::current()->RunUntilIdle();
 
   // Clear the locale pref so the statistics provider is pinged next time.
   g_browser_process->local_state()->SetString(prefs::kApplicationLocale,
                                               std::string());
 }
 
 IN_PROC_BROWSER_TEST_F(OobeLocalizationTest, NetworkScreenNonLatin) {
   // For a non-Latin keyboard layout like Russian, we expect to see the US
   // keyboard.
   RunLocalizationTest("ru", "xkb:ru::rus",
-                      "ru", kUSLayout);
+                      "ru", kUSLayout,
+                      "xkb:us::eng");
+
+  RunLocalizationTest("ru", "xkb:us::eng,xkb:ru::rus",
+                      "ru", kUSLayout,
+                      "xkb:us::eng");
 
   // IMEs do not load at OOBE, so we just expect to see the (Latin) Japanese
   // keyboard.
   RunLocalizationTest("ja", "xkb:jp::jpn",
-                      "ja", "xkb:jp::jpn");
+                      "ja", "xkb:jp::jpn",
+                      "xkb:jp::jpn,[xkb:us::eng]");
 }
 
 IN_PROC_BROWSER_TEST_F(OobeLocalizationTest, NetworkScreenKeyboardLayout) {
   // We don't use the Icelandic locale but the Icelandic keyboard layout
   // should still be selected when specified as the default.
   RunLocalizationTest("en-US", "xkb:is::ice",
-                      "en-US", "xkb:is::ice");
+                      "en-US", "xkb:is::ice",
+                      "xkb:is::ice,["
+                          "xkb:us::eng,xkb:us:intl:eng,xkb:us:altgr-intl:eng,"
+                          "xkb:us:dvorak:eng,xkb:us:colemak:eng]");
 }
 
 IN_PROC_BROWSER_TEST_F(OobeLocalizationTest, NetworkScreenFullLatin) {
   // French Swiss keyboard.
   RunLocalizationTest("fr", "xkb:ch:fr:fra",
-                      "fr", "xkb:ch:fr:fra");
+                      "fr", "xkb:ch:fr:fra",
+                      "xkb:ch:fr:fra,["
+                          "xkb:fr::fra,xkb:be::fra,xkb:ca::fra,"
+                          "xkb:ca:multix:fra,xkb:us::eng]");
 
   // German Swiss keyboard.
   RunLocalizationTest("de", "xkb:ch::ger",
-                      "de", "xkb:ch::ger");
+                      "de", "xkb:ch::ger",
+                      "xkb:ch::ger,["
+                          "xkb:de::ger,xkb:de:neo:ger,xkb:be::ger,xkb:us::eng"
+                      "]");
 }
 
 IN_PROC_BROWSER_TEST_F(OobeLocalizationTest, NetworkScreenMultipleLocales) {
- RunLocalizationTest("es,en-US,nl", "xkb:be::nld",
-                     "es,en-US,nl", "xkb:be::nld");
+  RunLocalizationTest("es,en-US,nl", "xkb:be::nld",
+                      "es,en-US,nl", "xkb:be::nld",
+                      "xkb:be::nld,[xkb:es::spa,xkb:latam::spa,xkb:us::eng]");
 
- RunLocalizationTest("ru,de", "xkb:ru::rus",
-                     "ru,de", kUSLayout);
+  RunLocalizationTest("ru,de", "xkb:ru::rus",
+                      "ru,de", kUSLayout

[michaelpg, 2014/02/17 22:39:10]

comma

[Alexander Alekseev, 2014/02/18 13:38:43]

Done.

+                      "xkb:us::eng");
 }
 
 }  // namespace chromeos