Revert of ChromeOS NetworkScreenHandler should not call CheckAndResolveLocale on UI thread.

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"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
-#include "chrome/browser/chromeos/login/login_manager_test.h"
 #include "chrome/browser/chromeos/login/login_wizard.h"
 #include "chrome/browser/chromeos/login/test/js_checker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/ime/input_method_whitelist.h"
 #include "chromeos/system/statistics_provider.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 59 matching lines @@
 
   virtual void Shutdown() override {
   }
 
   std::string initial_locale_;
   std::string keyboard_layout_;
 };
 
 }  // namespace system
 
-struct LocalizationTestParams {
-  const char* initial_locale;
-  const char* keyboard_layout;
-  const char* expected_locale;
-  const char* expected_keyboard_layout;
-  const char* expected_keyboard_select_control;
-} const oobe_localization_test_parameters[] = {
-      // ------------------ Non-Latin setup
-      // For a non-Latin keyboard layout like Russian, we expect to see the US
-      // keyboard.
-      {"ru", "xkb:ru::rus", "ru", kUSLayout, "xkb:us::eng"},
-      {"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.
-      {"ja", "xkb:jp::jpn", "ja", "xkb:jp::jpn", "xkb:jp::jpn,[xkb:us::eng]"},
-
-      // We don't use the Icelandic locale but the Icelandic keyboard layout
-      // should still be selected when specified as the default.
-      {"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]"},
-      // ------------------ Full Latin setup
-      // French Swiss keyboard.
-      {"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.
-      {"de",
-       "xkb:ch::ger",
-       "de",
-       "xkb:ch::ger",
-       "xkb:ch::ger,[xkb:de::ger,xkb:de:neo:ger,xkb:be::ger,xkb:us::eng]"},
-
-      // NetworkScreenMultipleLocales
-      {"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]"},
-
-      {"ru,de", "xkb:ru::rus", "ru,de", kUSLayout, "xkb:us::eng"},
-
-      // ------------------ Regional Locales
-      // Syntetic example to test correct merging of different locales.
-      {"fr-CH,it-CH,de-CH",
-       "xkb:fr::fra,xkb:it::ita,xkb:de::ger",
-       "fr-CH,it-CH,de-CH",
-       "xkb:fr::fra",
-       "xkb:fr::fra,xkb:it::ita,xkb:de::ger,[xkb:be::fra,xkb:ca::fra,"
-           "xkb:ch:fr:fra,xkb:ca:multix:fra,xkb:us::eng]"},
-
-      // Another syntetic example. Check that british keyboard is available.
-      {"en-AU",
-       "xkb:us::eng",
-       "en-AU",
-       "xkb:us::eng",
-       "xkb:us::eng,[xkb:gb:extd:eng,xkb:gb:dvorak:eng]"},
-};
-
-class OobeLocalizationTest
-    : public LoginManagerTest,
-      public testing::WithParamInterface<const LocalizationTestParams*> {
+class OobeLocalizationTest : public InProcessBrowserTest {
  public:
   OobeLocalizationTest();
   virtual ~OobeLocalizationTest();
 
   // 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.
   bool VerifyInitialOptions(const char* select_id,
                             const char* values,
                             bool check_separator);
 
   // Verifies that |value| exists in |select_id|.
   bool 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();
-
-  void WaitUntilJSIsReady() {
-    LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
-        LoginDisplayHostImpl::default_host());
-    if (!host)
-      return;
-    chromeos::OobeUI* oobe_ui = host->GetOobeUI();
-    if (!oobe_ui)
-      return;
-    base::RunLoop run_loop;
-    const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
-    if (!oobe_ui_ready)
-      run_loop.Run();
-  }
+  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_select_control);
 
  private:
   scoped_ptr<system::FakeStatisticsProvider> statistics_provider_;
   test::JSChecker checker;
 
   DISALLOW_COPY_AND_ASSIGN(OobeLocalizationTest);
 };
 
-OobeLocalizationTest::OobeLocalizationTest() : LoginManagerTest(false) {
+OobeLocalizationTest::OobeLocalizationTest() {
   statistics_provider_.reset(new system::FakeStatisticsProvider());
   // Set the instance returned by GetInstance() for testing.
   system::StatisticsProvider::SetTestProvider(statistics_provider_.get());
-
-  statistics_provider_->set_locale(GetParam()->initial_locale);
-  statistics_provider_->set_keyboard_layout(GetParam()->keyboard_layout);
 }
 
 OobeLocalizationTest::~OobeLocalizationTest() {
   system::StatisticsProvider::SetTestProvider(NULL);
 }
 
 bool OobeLocalizationTest::VerifyInitialOptions(const char* select_id,
                                                 const char* values,
                                                 bool check_separator) {
   const std::string expression = base::StringPrintf(
@@ skipping 90 matching lines @@
   std::string repl_old = "xkb:";
   std::string repl_new =
       extension_ime_util::GetInputMethodIDByEngineID("xkb:");
   while ((pos = result.find(repl_old, pos)) != std::string::npos) {
     result.replace(pos, repl_old.length(), repl_new);
     pos += repl_new.length();
   }
   return result;
 }
 
-void OobeLocalizationTest::RunLocalizationTest() {
-  const std::string initial_locale(GetParam()->initial_locale);
-  const std::string keyboard_layout(GetParam()->keyboard_layout);
-  const std::string expected_locale(GetParam()->expected_locale);
-  const std::string expected_keyboard_layout(
-      GetParam()->expected_keyboard_layout);
-  const std::string expected_keyboard_select_control(
-      GetParam()->expected_keyboard_select_control);
+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_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());
+
+  g_browser_process->local_state()->SetString(
+      prefs::kHardwareKeyboardLayout, keyboard_layout);
+
+  input_method::InputMethodManager::Get()
+      ->GetInputMethodUtil()
+      ->InitXkbInputMethodsForTesting();
 
   const std::string expected_keyboard_select =
       TranslateXKB2Extension(expected_keyboard_select_control);
 
-  WaitUntilJSIsReady();
-
-  const std::string first_language =
-      expected_locale.substr(0, expected_locale.find(','));
-  bool done = false;
-  const std::string waiting_script = base::StringPrintf(
-      "var screenElement = document.getElementById('language-select');"
-      "function SendReplyIfAcceptEnabled() {"
-      "  if ($('language-select').value != '%s')"
-      "    return false;"
-      "  domAutomationController.send(true);"
-      "  observer.disconnect();"
-      "  return true;"
-      "}"
-      "var observer = new MutationObserver(SendReplyIfAcceptEnabled);"
-      "if (!SendReplyIfAcceptEnabled()) {"
-      "  var options = { attributes: true };"
-      "  observer.observe(screenElement, options);"
-      "}",
-      first_language.c_str());
-
-  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-      static_cast<chromeos::LoginDisplayHostImpl*>(
-          chromeos::LoginDisplayHostImpl::default_host())
-          ->GetOobeUI()
-          ->web_ui()
-          ->GetWebContents(),
-      waiting_script,
-      &done));
+  // Bring up the OOBE network screen.
+  chromeos::ShowLoginWizard(chromeos::WizardController::kNetworkScreenName);
+  content::WindowedNotificationObserver(
+      chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
+      content::NotificationService::AllSources()).Wait();
 
   checker.set_web_contents(static_cast<chromeos::LoginDisplayHostImpl*>(
                            chromeos::LoginDisplayHostImpl::default_host())->
                            GetOobeUI()->web_ui()->GetWebContents());
 
   if (!VerifyInitialOptions(kLocaleSelect, expected_locale.c_str(), true)) {
     LOG(ERROR) << "Actual value of " << kLocaleSelect << ":\n"
                << DumpOptions(kLocaleSelect);
   }
   if (!VerifyInitialOptions(
@@ skipping 18 matching lines @@
 
   // 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_P(OobeLocalizationTest, LocalizationTest) {
-  RunLocalizationTest();
+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,
+                      "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",
+                      "xkb:jp::jpn,[xkb:us::eng]");
 }
 
-INSTANTIATE_TEST_CASE_P(
-    StructSequence,
-    OobeLocalizationTest,
-    testing::Range(&oobe_localization_test_parameters[0],
-                   &oobe_localization_test_parameters[arraysize(
-                       oobe_localization_test_parameters)]));
+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",
+                      "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",
+                      "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",
+                      "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",
+                      "xkb:be::nld,[xkb:es::spa,xkb:latam::spa,xkb:us::eng]");
+
+  RunLocalizationTest("ru,de", "xkb:ru::rus",
+                      "ru,de", kUSLayout,
+                      "xkb:us::eng");
+}
+
+IN_PROC_BROWSER_TEST_F(OobeLocalizationTest, NetworkScreenRegionalLocales) {
+  // Syntetic example to test correct merging of different locales.
+  RunLocalizationTest("fr-CH,it-CH,de-CH",
+                      "xkb:fr::fra,xkb:it::ita,xkb:de::ger",
+                      "fr-CH,it-CH,de-CH",
+                      "xkb:fr::fra",
+                      "xkb:fr::fra,xkb:it::ita,xkb:de::ger,["
+                          "xkb:be::fra,xkb:ca::fra,xkb:ch:fr:fra,"
+                          "xkb:ca:multix:fra,xkb:us::eng"
+                      "]");
+  // Another syntetic example. Check that british keyboard is available.
+  RunLocalizationTest("en-AU",
+                      "xkb:us::eng",
+                      "en-AU",
+                      "xkb:us::eng",
+                      "xkb:us::eng,[xkb:gb:extd:eng,xkb:gb:dvorak:eng]");
+}
+
 }  // namespace chromeos