OobeLocalizationTest.LocalizationTest : implement test timeouts.

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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/customization/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/screens/network_screen.h"
 #include "chrome/browser/chromeos/login/test/js_checker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
@@ skipping 12 matching lines @@
 #include "ui/base/ime/chromeos/input_method_whitelist.h"
 
 namespace base {
 class TaskRunner;
 }
 
 namespace chromeos {
 
 namespace {
 
+// Timeout for RunLoop::Run() in this test.
+const int kTimeoutSeconds = 2;
+
 // OOBE constants.
 const char kLocaleSelect[] = "language-select";
 const char kKeyboardSelect[] = "keyboard-select";
 
 const char kUSLayout[] = "xkb:us::eng";
+class TimedRunLoop {
+ public:
+  TimedRunLoop(const base::TimeDelta& timeout,
+               const std::string& failure_message)
+      : timeout_(timeout), message_(failure_message) {}
+
+  void Run() {
+    base::OneShotTimer timer;
+    timer.Start(FROM_HERE, timeout_,
+                base::Bind(&TimedRunLoop::OnTimeout, base::Unretained(this)));
+    loop_.Run();
+  }
+
+  void Quit() {
+    loop_.Quit();
+  }
+
+  base::Closure QuitClosure() {
+    return base::Bind(&TimedRunLoop::Quit, base::Unretained(this));
+  }
+
+ private:
+  void OnTimeout() {
+    LOG(FATAL) << "Timeout waiting for: " << message_;

[stevenjb, 2016/08/04 17:04:41]

This will cause the entire test suite to crash, which is not what we want.
Instead we should log an error and call loop_.Quit(), at which point the test
itself should fail.

[Alexander Alekseev, 2016/08/05 03:42:00]

Done.

+  }
+
+  const base::TimeDelta timeout_;
+  const std::string message_;
+  base::RunLoop loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimedRunLoop);
+};
 
 class LanguageListWaiter : public NetworkScreen::Observer {
  public:
-  explicit LanguageListWaiter(base::RunLoop& loop)
+  LanguageListWaiter()
       : network_screen_(
             NetworkScreen::Get(WizardController::default_controller())),
-        loop_(loop) {
+        loop_(base::TimeDelta::FromSeconds(kTimeoutSeconds), "LanguageList") {
     network_screen_->AddObserver(this);
     CheckLanguageList();
   }
 
   ~LanguageListWaiter() override { network_screen_->RemoveObserver(this); }
 
   // NetworkScreen::Observer implementation:
   void OnLanguageListReloaded() override { CheckLanguageList(); }
 
+  void Wait() {
+    if (LanguageListReady())
+      return;

[stevenjb, 2016/08/04 17:04:41]

Hmm, good catch, this might have been the problem.

+
+    loop_.Run();
+  }
+
  private:
+  bool LanguageListReady() const {
+    return network_screen_->GetLanguageList();
+  }
+
   void CheckLanguageList() {
-    if (network_screen_->GetLanguageList())
+    if (LanguageListReady())
       loop_.Quit();
   }
 
   NetworkScreen* network_screen_;
-  base::RunLoop& loop_;
+  TimedRunLoop loop_;
 };
 
 }  // namespace
 
 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;
@@ skipping 72 matching lines @@
   // Runs the test for the given locale and keyboard layout.
   void RunLocalizationTest();
 
   void WaitUntilJSIsReady() {
     LoginDisplayHost* host = LoginDisplayHost::default_host();
     if (!host)
       return;
     OobeUI* oobe_ui = host->GetOobeUI();
     if (!oobe_ui)
       return;
-    base::RunLoop run_loop;
+
+    TimedRunLoop run_loop(base::TimeDelta::FromSeconds(kTimeoutSeconds),
+                          "WaitUntilJSIsReady()");
     const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
     if (!oobe_ui_ready)
       run_loop.Run();
   }
 
  private:
   system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   test::JSChecker checker;
 
   DISALLOW_COPY_AND_ASSIGN(OobeLocalizationTest);
@@ skipping 115 matching lines @@
   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);
 
   const std::string expected_keyboard_select =
       TranslateXKB2Extension(expected_keyboard_select_control);
 
-  {
-    base::RunLoop loop;
-    LanguageListWaiter waiter(loop);
-    loop.Run();
-  }
+  LanguageListWaiter().Wait();
 
   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')"
@@ skipping 55 matching lines @@
   RunLocalizationTest();
 }
 
 INSTANTIATE_TEST_CASE_P(
     StructSequence,
     OobeLocalizationTest,
     testing::Range(&oobe_localization_test_parameters[0],
                    &oobe_localization_test_parameters[arraysize(
                        oobe_localization_test_parameters)]));
 }  // namespace chromeos