0

Revert "[base] Make test Run() timeouts fatal unless using GTest."

This reverts commit e7f522eeb9.

Reason for revert: suspect causing compile failure on linux-chromeos-chrome.

Sample build: https://ci.chromium.org/p/chrome/builders/ci/linux-chromeos-chrome/2923

Sample log: https://logs.chromium.org/logs/chrome/buildbucket/cr-buildbucket.appspot.com/8888898680396285712/+/steps/compile/0/stdout?format=raw

E.g.
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:323:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
  const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
                                         ^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
      ^
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:356:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
  const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
                                         ^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
      ^
../../chrome/browser/ui/ash/assistant/assistant_test_mixin.cc:371:42: error: variable has incomplete type 'const base::test::ScopedRunLoopTimeout'
  const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
                                         ^
../../base/run_loop.h:28:7: note: forward declaration of 'base::test::ScopedRunLoopTimeout'
class ScopedRunLoopTimeout;
      ^
3 errors generated.


Original change's description:
> [base] Make test Run() timeouts fatal unless using GTest.
> 
> The Run() timeouts set for tests now default to crashing the calling
> process. This ensures that Run() timeouts cause visible failures
> regardless of whether the calling suite uses GTest.  Suites which do use
> GTest can switch to having timeouts reported via GTEST_FAIL() by calling:
> 
>   base::test::ScopedRunLoopTimeout::SetUseGTestFailOnTimeout();
> 
> Test suites derived from base::TestSuite will have this option set for
> them as part of the TestSuite initialization.
> 
> The RunLoop::ScopedRunTimeoutForTest helper is moved to
> base::test::ScopedRunLoopTimeout, to allow it to have GTest dependencies.
> 
> Bug: 1021777, 1014767
> Change-Id: Id372c666c6455e56e52034ae528b417a0c23143c
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1932464
> Commit-Queue: Wez <wez@chromium.org>
> Auto-Submit: Wez <wez@chromium.org>
> Reviewed-by: Scott Violet <sky@chromium.org>
> Reviewed-by: Gabriel Charette <gab@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#739760}

TBR=sky@chromium.org,wez@chromium.org,gab@chromium.org,kmarshall@chromium.org

Change-Id: Ib0927699042f216971448da8b1d70619c0545367
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1021777, 1014767
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2045697
Reviewed-by: Takashi Sakamoto <tasak@google.com>
Commit-Queue: Takashi Sakamoto <tasak@google.com>
Cr-Commit-Position: refs/heads/master@{#739790}
This commit is contained in:
Takashi Sakamoto
2020-02-10 04:58:55 +00:00
committed by Commit Bot
parent 736aeeec58
commit 21fa8d0bbd
28 changed files with 205 additions and 362 deletions

@ -2700,7 +2700,6 @@ test("base_unittests") {
"test/scoped_feature_list_unittest.cc",
"test/scoped_mock_clock_override_unittest.cc",
"test/scoped_mock_time_message_loop_task_runner_unittest.cc",
"test/scoped_run_loop_timeout_unittest.cc",
"test/task_environment_unittest.cc",
"test/test_mock_time_task_runner_unittest.cc",
"test/test_pending_task_unittest.cc",

@ -15,7 +15,9 @@ namespace base {
namespace fuchsia {
ServiceDirectoryTestBase::ServiceDirectoryTestBase()
: run_timeout_(TestTimeouts::action_timeout()) {
: run_timeout_(TestTimeouts::action_timeout(), BindRepeating([]() {
ADD_FAILURE() << "Run() timed out.";
})) {
// Mount service dir and publish the service.
outgoing_directory_ = std::make_unique<sys::OutgoingDirectory>();
fidl::InterfaceHandle<::fuchsia::io::Directory> directory;

@ -13,7 +13,7 @@
#include "base/fuchsia/scoped_service_binding.h"
#include "base/fuchsia/test_interface_impl.h"
#include "base/fuchsia/testfidl/cpp/fidl.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
@ -29,7 +29,7 @@ class ServiceDirectoryTestBase : public testing::Test {
zx_status_t expected_error);
protected:
const test::ScopedRunLoopTimeout run_timeout_;
const RunLoop::ScopedRunTimeoutForTest run_timeout_;
base::test::SingleThreadTaskEnvironment task_environment_{
base::test::SingleThreadTaskEnvironment::MainThreadType::IO};

@ -34,18 +34,49 @@ void ProxyToTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner,
task_runner->PostTask(FROM_HERE, std::move(closure));
}
ThreadLocalPointer<const RunLoop::RunLoopTimeout>& RunLoopTimeoutTLS() {
static NoDestructor<ThreadLocalPointer<const RunLoop::RunLoopTimeout>> tls;
ThreadLocalPointer<RunLoop::ScopedRunTimeoutForTest>&
ScopedRunTimeoutForTestTLS() {
static NoDestructor<ThreadLocalPointer<RunLoop::ScopedRunTimeoutForTest>> tls;
return *tls;
}
void OnRunLoopTimeout(RunLoop* run_loop, OnceClosure on_timeout) {
void OnRunTimeout(RunLoop* run_loop, OnceClosure on_timeout) {
run_loop->Quit();
std::move(on_timeout).Run();
}
} // namespace
RunLoop::ScopedRunTimeoutForTest::ScopedRunTimeoutForTest(
TimeDelta timeout,
RepeatingClosure on_timeout)
: timeout_(timeout),
on_timeout_(std::move(on_timeout)),
nested_timeout_(ScopedRunTimeoutForTestTLS().Get()) {
DCHECK_GT(timeout_, TimeDelta());
DCHECK(on_timeout_);
ScopedRunTimeoutForTestTLS().Set(this);
}
RunLoop::ScopedRunTimeoutForTest::~ScopedRunTimeoutForTest() {
ScopedRunTimeoutForTestTLS().Set(nested_timeout_);
}
// static
const RunLoop::ScopedRunTimeoutForTest*
RunLoop::ScopedRunTimeoutForTest::Current() {
return ScopedRunTimeoutForTestTLS().Get();
}
RunLoop::ScopedDisableRunTimeoutForTest::ScopedDisableRunTimeoutForTest()
: nested_timeout_(ScopedRunTimeoutForTestTLS().Get()) {
ScopedRunTimeoutForTestTLS().Set(nullptr);
}
RunLoop::ScopedDisableRunTimeoutForTest::~ScopedDisableRunTimeoutForTest() {
ScopedRunTimeoutForTestTLS().Set(nested_timeout_);
}
RunLoop::Delegate::Delegate() {
// The Delegate can be created on another thread. It is only bound in
// RegisterDelegateForCurrentThread().
@ -106,16 +137,16 @@ void RunLoop::Run() {
if (!BeforeRun())
return;
// If there is a RunLoopTimeout active then set the timeout.
// If there is a ScopedRunTimeoutForTest active then set the timeout.
// TODO(crbug.com/905412): Use real-time for Run() timeouts so that they
// can be applied even in tests which mock TimeTicks::Now().
CancelableOnceClosure cancelable_timeout;
const RunLoopTimeout* run_timeout = GetTimeoutForCurrentThread();
ScopedRunTimeoutForTest* run_timeout = ScopedRunTimeoutForTestTLS().Get();
if (run_timeout) {
cancelable_timeout.Reset(
BindOnce(&OnRunLoopTimeout, Unretained(this), run_timeout->on_timeout));
origin_task_runner_->PostDelayedTask(
FROM_HERE, cancelable_timeout.callback(), run_timeout->timeout);
BindOnce(&OnRunTimeout, Unretained(this), run_timeout->on_timeout()));
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, cancelable_timeout.callback(), run_timeout->timeout());
}
DCHECK_EQ(this, delegate_->active_run_loops_.top());
@ -273,12 +304,10 @@ RunLoop::ScopedDisallowRunningForTesting::~ScopedDisallowRunningForTesting() =
#endif // DCHECK_IS_ON()
void RunLoop::RunUntilConditionForTest(RepeatingCallback<bool()> condition) {
CHECK(GetTimeoutForCurrentThread());
const RunLoopTimeout* old_timeout = GetTimeoutForCurrentThread();
RunLoopTimeout run_timeout;
run_timeout.timeout = old_timeout->timeout;
run_timeout.on_timeout = DoNothing();
RunLoopTimeoutTLS().Set(&run_timeout);
CHECK(ScopedRunTimeoutForTest::Current());
OnceClosure on_failure = ScopedRunTimeoutForTest::Current()->on_timeout();
ScopedRunTimeoutForTest run_timeout(
ScopedRunTimeoutForTest::Current()->timeout(), DoNothing());
auto check_condition = BindRepeating(
[](const RepeatingCallback<bool()>& condition, RunLoop* loop) {
if (condition.Run())
@ -290,22 +319,7 @@ void RunLoop::RunUntilConditionForTest(RepeatingCallback<bool()> condition) {
check_condition);
Run();
if (!condition.Run())
old_timeout->on_timeout.Run();
RunLoopTimeoutTLS().Set(old_timeout);
}
RunLoop::RunLoopTimeout::RunLoopTimeout() = default;
RunLoop::RunLoopTimeout::~RunLoopTimeout() = default;
// static
void RunLoop::SetTimeoutForCurrentThread(const RunLoopTimeout* timeout) {
RunLoopTimeoutTLS().Set(timeout);
}
// static
const RunLoop::RunLoopTimeout* RunLoop::GetTimeoutForCurrentThread() {
return RunLoopTimeoutTLS().Get();
std::move(on_failure).Run();
}
bool RunLoop::BeforeRun() {

@ -12,7 +12,6 @@
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/containers/stack.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
@ -23,12 +22,6 @@
#include "build/build_config.h"
namespace base {
namespace test {
class ScopedRunLoopTimeout;
class ScopedDisableRunLoopTimeout;
} // namespace test
#if defined(OS_ANDROID)
class MessagePumpForUI;
#endif
@ -253,6 +246,65 @@ class BASE_EXPORT RunLoop {
static void QuitCurrentWhenIdleDeprecated();
static RepeatingClosure QuitCurrentWhenIdleClosureDeprecated();
// Configures all RunLoop::Run() calls on the current thread to run the
// supplied |on_timeout| callback if they run for longer than |timeout|.
//
// Specifying Run() timeouts per-thread avoids the need to cope with Run()s
// executing concurrently with ScopedRunTimeoutForTest initialization or
// teardown, and allows "default" timeouts to be specified by suites, rather
// than explicitly configuring them for every RunLoop, in each test.
//
// Tests can temporarily override any currently-active Run() timeout, e.g. to
// allow a step to Run() for longer than the suite's default timeout, by
// creating a new ScopedRunTimeoutForTest on their stack, e.g:
//
// ScopedRunTimeoutForTest default_timeout(kDefaultRunTimeout, on_timeout);
// ... do other test stuff ...
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
// ...
// {
// ScopedRunTimeoutForTest specific_timeout(kTestSpecificTimeout, ...);
// RunLoop().Run(); // Run for up to kTestSpecificTimeout.
// }
// ...
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
//
// The currently-active timeout can also be temporarily disabled:
// ScopedDisableRunTimeoutForTest disable_timeout;
//
// TaskEnvironment applies a default Run() timeout after which a
// LOG(FATAL) is performed, to dump a crash stack for diagnosis. Tests adding
// their own Run() timeouts can use e.g. MakeExpectedNotRunClosure().
class BASE_EXPORT ScopedRunTimeoutForTest {
public:
ScopedRunTimeoutForTest(TimeDelta timeout, RepeatingClosure on_timeout);
~ScopedRunTimeoutForTest();
// Returns the active ScopedRunTimeoutForTest on the calling thread, if any,
// or null otherwise.
static const RunLoop::ScopedRunTimeoutForTest* Current();
TimeDelta timeout() const { return timeout_; }
const RepeatingClosure& on_timeout() const { return on_timeout_; }
private:
const TimeDelta timeout_;
const RepeatingClosure on_timeout_;
ScopedRunTimeoutForTest* const nested_timeout_;
DISALLOW_COPY_AND_ASSIGN(ScopedRunTimeoutForTest);
};
class BASE_EXPORT ScopedDisableRunTimeoutForTest {
public:
ScopedDisableRunTimeoutForTest();
~ScopedDisableRunTimeoutForTest();
private:
ScopedRunTimeoutForTest* const nested_timeout_;
DISALLOW_COPY_AND_ASSIGN(ScopedDisableRunTimeoutForTest);
};
// Run() will DCHECK if called while there's a ScopedDisallowRunningForTesting
// in scope on its thread. This is useful to add safety to some test
// constructs which allow multiple task runners to share the main thread in
@ -283,15 +335,6 @@ class BASE_EXPORT RunLoop {
// is not feasible. Use Run() and QuitClosure() where possible.
void RunUntilConditionForTest(RepeatingCallback<bool()> condition);
// Support for //base/test/scoped_run_loop_timeout.h.
// This must be public for access by the implementation code in run_loop.cc.
struct BASE_EXPORT RunLoopTimeout {
RunLoopTimeout();
~RunLoopTimeout();
TimeDelta timeout;
RepeatingClosure on_timeout;
};
private:
FRIEND_TEST_ALL_PREFIXES(MessageLoopTypedTest, RunLoopQuitOrderAfter);
@ -307,13 +350,6 @@ class BASE_EXPORT RunLoop {
friend class MessagePumpUIApplication;
#endif
// Support for //base/test/scoped_run_loop_timeout.h.
friend class test::ScopedRunLoopTimeout;
friend class test::ScopedDisableRunLoopTimeout;
static void SetTimeoutForCurrentThread(const RunLoopTimeout* timeout);
static const RunLoopTimeout* GetTimeoutForCurrentThread();
// Return false to abort the Run.
bool BeforeRun();
void AfterRun();

@ -19,7 +19,6 @@
#include "base/synchronization/waitable_event.h"
#include "base/test/bind_test_util.h"
#include "base/test/gtest_util.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/task_environment.h"
#include "base/test/test_timeouts.h"
#include "base/threading/platform_thread.h"
@ -556,11 +555,10 @@ TEST(RunLoopUntilConditionTest, FailsTestOnTimeout) {
// Expect the Run() timeout to be run when |condition| is false and the loop
// times out.
const test::ScopedRunLoopTimeout short_timeout(
TimeDelta::FromMilliseconds(10));
EXPECT_FATAL_FAILURE(
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; })),
"RunLoop::Run() timed out.");
const RunLoop::ScopedRunTimeoutForTest short_timeout(
TimeDelta::FromMilliseconds(10),
MakeExpectedRunAtLeastOnceClosure(FROM_HERE));
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; }));
}
TEST(RunLoopUntilConditionTest, FailsTestIfConditionNotMetOnQuit) {
@ -569,13 +567,12 @@ TEST(RunLoopUntilConditionTest, FailsTestIfConditionNotMetOnQuit) {
// Expect the Run() timeout to be run when |condition| is false and the loop
// Quit()s prematurely.
const test::ScopedRunLoopTimeout short_timeout(
TimeDelta::FromMilliseconds(10));
const RunLoop::ScopedRunTimeoutForTest short_timeout(
TimeDelta::FromMilliseconds(10),
MakeExpectedRunAtLeastOnceClosure(FROM_HERE));
// Running with a never-true condition will fire the on-timeout callback.
EXPECT_FATAL_FAILURE(
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; })),
"RunLoop::Run() timed out.");
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return false; }));
}
TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnQuit) {
@ -583,8 +580,8 @@ TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnQuit) {
RunLoop loop;
// Verify that the call does not trigger the Run() timeout.
const test::ScopedRunLoopTimeout short_timeout(
TimeDelta::FromMilliseconds(10));
const RunLoop::ScopedRunTimeoutForTest short_timeout(
TimeDelta::FromMilliseconds(10), MakeExpectedNotRunClosure(FROM_HERE));
SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE, loop.QuitClosure());
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return true; }));
}
@ -596,8 +593,8 @@ TEST(RunLoopUntilConditionTest, NoEffectIfConditionMetOnTimeout) {
// Verify that the call does not trigger the Run() timeout.
// Note that |short_timeout| must be shorter than the RunUntilConditionForTest
// polling frequency.
const test::ScopedRunLoopTimeout short_timeout(
TimeDelta::FromMilliseconds(10));
const RunLoop::ScopedRunTimeoutForTest short_timeout(
TimeDelta::FromMilliseconds(10), MakeExpectedNotRunClosure(FROM_HERE));
RunLoop().RunUntilConditionForTest(BindRepeating([]() { return true; }));
}
@ -606,7 +603,8 @@ TEST(RunLoopUntilConditionTest, QuitsLoopIfConditionMetOnPoll) {
RunLoop loop;
// Configure a long timeout so it won't fire before we poll.
const test::ScopedRunLoopTimeout long_timeout(TestTimeouts::action_timeout());
const RunLoop::ScopedRunTimeoutForTest long_timeout(
TestTimeouts::action_timeout(), MakeExpectedNotRunClosure(FROM_HERE));
// Arrange to post a task to the loop after the Run()-timeout has been
// started, set to run after the |condition| is polled and before the Run()

@ -104,8 +104,6 @@ static_library("test_support") {
"scoped_mock_time_message_loop_task_runner.h",
"scoped_path_override.cc",
"scoped_path_override.h",
"scoped_run_loop_timeout.cc",
"scoped_run_loop_timeout.h",
"sequenced_task_runner_test_template.cc",
"sequenced_task_runner_test_template.h",
"simple_test_clock.cc",

@ -1,65 +0,0 @@
// Copyright 2019 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/test/scoped_run_loop_timeout.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace test {
namespace {
bool g_add_gtest_failure_on_timeout = false;
}
ScopedRunLoopTimeout::ScopedRunLoopTimeout(TimeDelta timeout)
: nested_timeout_(RunLoop::GetTimeoutForCurrentThread()) {
DCHECK_GT(timeout, TimeDelta());
run_timeout_.timeout = timeout;
if (g_add_gtest_failure_on_timeout) {
run_timeout_.on_timeout = base::BindRepeating(
[]() { GTEST_FAIL() << "RunLoop::Run() timed out."; });
} else {
run_timeout_.on_timeout = base::BindRepeating(
[]() { LOG(FATAL) << "RunLoop::Run() timed out."; });
}
RunLoop::SetTimeoutForCurrentThread(&run_timeout_);
}
ScopedRunLoopTimeout::~ScopedRunLoopTimeout() {
RunLoop::SetTimeoutForCurrentThread(nested_timeout_);
}
// static
bool ScopedRunLoopTimeout::ExistsForCurrentThread() {
return RunLoop::GetTimeoutForCurrentThread() != nullptr;
}
// static
void ScopedRunLoopTimeout::SetAddGTestFailureOnTimeout() {
g_add_gtest_failure_on_timeout = true;
}
// static
const RunLoop::RunLoopTimeout*
ScopedRunLoopTimeout::GetTimeoutForCurrentThread() {
return RunLoop::GetTimeoutForCurrentThread();
}
ScopedDisableRunLoopTimeout::ScopedDisableRunLoopTimeout()
: nested_timeout_(RunLoop::GetTimeoutForCurrentThread()) {
RunLoop::SetTimeoutForCurrentThread(nullptr);
}
ScopedDisableRunLoopTimeout::~ScopedDisableRunLoopTimeout() {
RunLoop::SetTimeoutForCurrentThread(nested_timeout_);
}
} // namespace test
} // namespace base

@ -1,97 +0,0 @@
// Copyright 2019 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.
#ifndef BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_
#define BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_
#include "base/run_loop.h"
#include "base/time/time.h"
namespace content {
FORWARD_DECLARE_TEST(ContentBrowserTest, RunTimeoutInstalled);
}
namespace base {
namespace test {
FORWARD_DECLARE_TEST(TaskEnvironmentTest, SetsDefaultRunTimeout);
// Configures all RunLoop::Run() calls on the current thread to run the
// supplied |on_timeout| callback if they run for longer than |timeout|.
//
// Specifying Run() timeouts per-thread avoids the need to cope with Run()s
// executing concurrently with ScopedRunLoopTimeout initialization or
// teardown, and allows "default" timeouts to be specified by suites, rather
// than explicitly configuring them for every RunLoop, in each test.
//
// This is used by test classes including TaskEnvironment and TestSuite to
// set a default Run() timeout on the main thread of all tests which use them.
//
// Tests which have steps which need to Run() for longer than their suite's
// default (if any) allows can override the active timeout by creating a nested
// ScopedRunLoopTimeout on their stack, e.g:
//
// ScopedRunLoopTimeout default_timeout(kDefaultRunTimeout);
// ... do other test stuff ...
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
// ...
// {
// ScopedRunLoopTimeout specific_timeout(kTestSpecificTimeout);
// RunLoop().Run(); // Run for up to kTestSpecificTimeout.
// }
// ...
// RunLoop().Run(); // Run for up to kDefaultRunTimeout.
//
// The currently-active timeout can also be temporarily disabled:
// ScopedDisableRunLoopTimeout disable_timeout;
//
// By default LOG(FATAL) will be invoked on Run() timeout. Test binaries
// can opt-in to using ADD_FAILURE() instead by calling
// SetAddGTestFailureOnTimeout() during process initialization.
//
// TaskEnvironment applies a default Run() timeout.
class ScopedRunLoopTimeout {
public:
ScopedRunLoopTimeout(TimeDelta timeout);
~ScopedRunLoopTimeout();
ScopedRunLoopTimeout(const ScopedRunLoopTimeout&) = delete;
ScopedRunLoopTimeout& operator=(const ScopedRunLoopTimeout&) = delete;
// Returns true if there is a Run() timeout configured on the current thread.
static bool ExistsForCurrentThread();
static void SetAddGTestFailureOnTimeout();
protected:
FRIEND_TEST_ALL_PREFIXES(ScopedRunLoopRunTimeoutTest, TimesOut);
FRIEND_TEST_ALL_PREFIXES(ScopedRunLoopRunTimeoutTest, RunTasksUntilTimeout);
FRIEND_TEST_ALL_PREFIXES(TaskEnvironmentTest, SetsDefaultRunTimeout);
FRIEND_TEST_ALL_PREFIXES(content::ContentBrowserTest, RunTimeoutInstalled);
// Exposes the RunLoopTimeout to the friend tests (see above).
static const RunLoop::RunLoopTimeout* GetTimeoutForCurrentThread();
const RunLoop::RunLoopTimeout* const nested_timeout_;
RunLoop::RunLoopTimeout run_timeout_;
};
class ScopedDisableRunLoopTimeout {
public:
ScopedDisableRunLoopTimeout();
~ScopedDisableRunLoopTimeout();
ScopedDisableRunLoopTimeout(const ScopedDisableRunLoopTimeout&) = delete;
ScopedDisableRunLoopTimeout& operator=(const ScopedDisableRunLoopTimeout&) =
delete;
private:
const RunLoop::RunLoopTimeout* const nested_timeout_;
};
} // namespace test
} // namespace base
#endif // BASE_TEST_SCOPED_RUN_LOOP_TIMEOUT_H_

@ -1,65 +0,0 @@
// Copyright 2020 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/test/scoped_run_loop_timeout.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/location.h"
#include "base/test/bind_test_util.h"
#include "base/test/gtest_util.h"
#include "base/test/task_environment.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest-spi.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace test {
TEST(ScopedRunLoopTimeoutTest, TimesOut) {
TaskEnvironment task_environment;
RunLoop run_loop;
static constexpr auto kArbitraryTimeout = TimeDelta::FromMilliseconds(10);
ScopedRunLoopTimeout run_timeout(kArbitraryTimeout);
// Since the delayed task will be posted only after the message pump starts
// running, the ScopedRunLoopTimeout will already have started to elapse,
// so if Run() exits at the correct time then our delayed task will not run.
SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
BindOnce(IgnoreResult(&SequencedTaskRunner::PostDelayedTask),
SequencedTaskRunnerHandle::Get(), FROM_HERE,
MakeExpectedNotRunClosure(FROM_HERE), kArbitraryTimeout));
// This task should get to run before Run() times-out.
SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, MakeExpectedRunClosure(FROM_HERE), kArbitraryTimeout);
// EXPECT_FATAL_FAILURE() can only reference globals and statics.
static RunLoop& static_loop = run_loop;
EXPECT_FATAL_FAILURE(static_loop.Run(), "Run() timed out.");
}
TEST(ScopedRunLoopTimeoutTest, RunTasksUntilTimeout) {
TaskEnvironment task_environment;
RunLoop run_loop;
static constexpr auto kArbitraryTimeout = TimeDelta::FromMilliseconds(10);
ScopedRunLoopTimeout run_timeout(kArbitraryTimeout);
// Posting a task with the same delay as our timeout, immediately before
// calling Run(), means it should get to run. Since this uses QuitWhenIdle(),
// the Run() timeout callback should also get to run.
SequencedTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, MakeExpectedRunClosure(FROM_HERE), kArbitraryTimeout);
// EXPECT_FATAL_FAILURE() can only reference globals and statics.
static RunLoop& static_loop = run_loop;
EXPECT_FATAL_FAILURE(static_loop.Run(), "Run() timed out.");
}
} // namespace test
} // namespace base

@ -380,11 +380,22 @@ TaskEnvironment::TaskEnvironment(
scoped_lazy_task_runner_list_for_testing_(
std::make_unique<internal::ScopedLazyTaskRunnerListForTesting>()),
// TODO(https://crbug.com/922098): Enable Run() timeouts even for
// instances created with TimeSource::MOCK_TIME.
run_loop_timeout_(mock_time_domain_
? nullptr
: std::make_unique<ScopedRunLoopTimeout>(
TestTimeouts::action_timeout())) {
// instances created with *MOCK_TIME.
run_loop_timeout_(
mock_time_domain_
? nullptr
: std::make_unique<RunLoop::ScopedRunTimeoutForTest>(
TestTimeouts::action_timeout(),
BindRepeating(
[](sequence_manager::SequenceManager*
sequence_manager) {
ADD_FAILURE()
<< "RunLoop::Run() timed out with the following "
"pending task(s) in its TaskEnvironment's "
"main thread queue:\n"
<< sequence_manager->DescribeAllPendingTasks();
},
Unretained(sequence_manager_.get())))) {
CHECK(!base::ThreadTaskRunnerHandle::IsSet());
// If |subclass_creates_default_taskrunner| is true then initialization is
// deferred until DeferredInitFromSubclass().

@ -11,10 +11,10 @@
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/task/lazy_thread_pool_task_runner.h"
#include "base/task/sequence_manager/sequence_manager.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "base/traits_bag.h"
@ -394,7 +394,7 @@ class TaskEnvironment {
scoped_lazy_task_runner_list_for_testing_;
// Sets RunLoop::Run() to LOG(FATAL) if not Quit() in a timely manner.
std::unique_ptr<ScopedRunLoopTimeout> run_loop_timeout_;
std::unique_ptr<RunLoop::ScopedRunTimeoutForTest> run_loop_timeout_;
std::unique_ptr<bool> owns_instance_ = std::make_unique<bool>(true);

@ -23,7 +23,6 @@
#include "base/test/gtest_util.h"
#include "base/test/mock_callback.h"
#include "base/test/mock_log.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/test_timeouts.h"
#include "base/threading/platform_thread.h"
#include "base/threading/sequence_local_storage_slot.h"
@ -839,8 +838,8 @@ TEST_F(TaskEnvironmentTest, ThreadPoolPoolAllowsMTA) {
#endif // defined(OS_WIN)
TEST_F(TaskEnvironmentTest, SetsDefaultRunTimeout) {
const RunLoop::RunLoopTimeout* old_run_timeout =
ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
const RunLoop::ScopedRunTimeoutForTest* old_run_timeout =
RunLoop::ScopedRunTimeoutForTest::Current();
{
TaskEnvironment task_environment;
@ -848,21 +847,22 @@ TEST_F(TaskEnvironmentTest, SetsDefaultRunTimeout) {
// TaskEnvironment should set a default Run() timeout that fails the
// calling test (before test_launcher_timeout()).
const RunLoop::RunLoopTimeout* run_timeout =
ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
const RunLoop::ScopedRunTimeoutForTest* run_timeout =
RunLoop::ScopedRunTimeoutForTest::Current();
EXPECT_NE(run_timeout, old_run_timeout);
EXPECT_TRUE(run_timeout);
if (!debug::BeingDebugged()) {
EXPECT_LT(run_timeout->timeout, TestTimeouts::test_launcher_timeout());
EXPECT_LT(run_timeout->timeout(), TestTimeouts::test_launcher_timeout());
}
static const RepeatingClosure& static_on_timeout = run_timeout->on_timeout;
EXPECT_FATAL_FAILURE(static_on_timeout.Run(), "RunLoop::Run() timed out");
EXPECT_NONFATAL_FAILURE({ run_timeout->on_timeout().Run(); },
"RunLoop::Run() timed out");
}
EXPECT_EQ(ScopedRunLoopTimeout::GetTimeoutForCurrentThread(),
old_run_timeout);
EXPECT_EQ(RunLoop::ScopedRunTimeoutForTest::Current(), old_run_timeout);
}
namespace {}
TEST_F(TaskEnvironmentTest, DescribePendingMainThreadTasks) {
TaskEnvironment task_environment;
ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing());
@ -1028,7 +1028,7 @@ TEST_F(TaskEnvironmentTest, RunLoopDriveable) {
// Disable Run() timeout here, otherwise we'll fast-forward to it before we
// reach the quit task.
ScopedDisableRunLoopTimeout disable_timeout;
RunLoop::ScopedDisableRunTimeoutForTest disable_timeout;
RunLoop run_loop;
ThreadTaskRunnerHandle::Get()->PostDelayedTask(

@ -37,7 +37,6 @@
#include "base/test/mock_entropy_provider.h"
#include "base/test/multiprocess_test.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/test_switches.h"
#include "base/test/test_timeouts.h"
#include "base/threading/platform_thread.h"
@ -581,8 +580,6 @@ void TestSuite::SuppressErrorDialogs() {
void TestSuite::Initialize() {
DCHECK(!is_initialized_);
test::ScopedRunLoopTimeout::SetAddGTestFailureOnTimeout();
const CommandLine* command_line = CommandLine::ForCurrentProcess();
#if !defined(OS_IOS)
if (command_line->HasSwitch(switches::kWaitForDebugger)) {

@ -430,8 +430,9 @@ TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInModel) {
#if defined(OS_ANDROID)
// TODO(https://crbug.com/1002762): Fix this test to run in < action_timeout()
// on the Android bots.
const base::test::ScopedRunLoopTimeout increased_run_timeout(
TestTimeouts::action_max_timeout());
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
TestTimeouts::action_max_timeout(),
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
#endif // defined(OS_ANDROID)
clock()->Advance(base::TimeDelta::FromHours(3));

@ -13,6 +13,7 @@
#include "ash/public/mojom/assistant_state_controller.mojom-shared.h"
#include "base/auto_reset.h"
#include "base/run_loop.h"
#include "base/test/bind_test_util.h"
#include "base/time/time.h"
#include "chrome/browser/chromeos/login/test/embedded_test_server_mixin.h"
#include "chrome/browser/chromeos/login/test/fake_gaia_mixin.h"
@ -320,8 +321,8 @@ void AssistantTestMixin::TearDownOnMainThread() {
void AssistantTestMixin::StartAssistantAndWaitForReady(
base::TimeDelta wait_timeout) {
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
// Note: You might be tempted to call this function from SetUpOnMainThread(),
// but that will not work as the Assistant service can not start until
// |BrowserTestBase| calls InitializeNetworkProcess(), which it only does
@ -353,7 +354,8 @@ void AssistantTestMixin::SendTextQuery(const std::string& query) {
void AssistantTestMixin::ExpectCardResponse(
const std::string& expected_response,
base::TimeDelta wait_timeout) {
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
CardResponseWaiter waiter(test_api_->ui_element_container(),
{expected_response});
waiter.RunUntilResponseReceived();
@ -368,7 +370,8 @@ void AssistantTestMixin::ExpectTextResponse(
void AssistantTestMixin::ExpectAnyOfTheseTextResponses(
const std::vector<std::string>& expected_responses,
base::TimeDelta wait_timeout) {
const base::test::ScopedRunLoopTimeout run_timeout(wait_timeout);
const base::RunLoop::ScopedRunTimeoutForTest run_timeout(
wait_timeout, base::MakeExpectedNotRunClosure(FROM_HERE));
TextResponseWaiter waiter(test_api_->ui_element_container(),
expected_responses);
waiter.RunUntilResponseReceived();

@ -15,7 +15,6 @@
#include "base/single_thread_task_runner.h"
#include "base/strings/stringprintf.h"
#include "base/test/bind_test_util.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/task_environment.h"
#include "base/threading/thread_task_runner_handle.h"
#include "chrome/common/cloud_print/cloud_print_constants.h"
@ -609,8 +608,13 @@ void PrinterJobHandlerTest::BeginTest(int timeout_seconds) {
base::RunLoop run_loop;
active_run_loop_quit_closure_ = run_loop.QuitWhenIdleClosure();
base::test::ScopedRunLoopTimeout run_timeout(
base::TimeDelta::FromSeconds(timeout_seconds));
base::RunLoop::ScopedRunTimeoutForTest run_timeout(
base::TimeDelta::FromSeconds(timeout_seconds),
base::BindLambdaForTesting([&]() {
ADD_FAILURE();
run_loop.QuitWhenIdle();
}));
run_loop.Run();
}

@ -8,8 +8,8 @@
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/test_file_util.h"
#include "base/timer/elapsed_timer.h"
#include "components/visitedlink/browser/visitedlink_writer.h"
@ -183,7 +183,7 @@ TEST_F(VisitedLink, TestAddAndQuery) {
// Tests how long it takes to write and read a large database to and from disk.
TEST_F(VisitedLink, TestBigTable) {
base::test::ScopedDisableRunLoopTimeout disable_run_timeout;
base::RunLoop::ScopedDisableRunTimeoutForTest disable_run_timeout;
// create a big DB
{
TimeLogger table_initialization_timer(kMetricTableInitMs);

@ -28,7 +28,6 @@
#include "base/task/post_task.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/test/bind_test_util.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/test_timeouts.h"
#include "base/threading/thread_restrictions.h"
#include "build/build_config.h"
@ -604,14 +603,16 @@ void BrowserTestBase::ProxyRunTestOnMainThreadLoop() {
#endif
// Install a RunLoop timeout if none is present but do not override tests that
// set a ScopedLoopRunTimeout from their fixture's constructor (which
// set a ScopedRunTimeoutForTest from their fixture's constructor (which
// happens as part of setting up the test factory in gtest while
// ProxyRunTestOnMainThreadLoop() happens later as part of SetUp()).
base::Optional<base::test::ScopedRunLoopTimeout> scoped_run_timeout;
if (!base::test::ScopedRunLoopTimeout::ExistsForCurrentThread()) {
base::Optional<base::RunLoop::ScopedRunTimeoutForTest> scoped_run_timeout;
if (!base::RunLoop::ScopedRunTimeoutForTest::Current()) {
// TODO(https://crbug.com/918724): determine whether the timeout can be
// reduced from action_max_timeout() to action_timeout().
scoped_run_timeout.emplace(TestTimeouts::action_max_timeout());
scoped_run_timeout.emplace(TestTimeouts::action_max_timeout(),
base::MakeExpectedNotRunClosure(
FROM_HERE, "RunLoop::Run() timed out."));
}
#if defined(OS_POSIX)

@ -16,7 +16,6 @@
#include "base/test/launcher/test_launcher.h"
#include "base/test/launcher/test_launcher_test_utils.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/test_switches.h"
#include "base/test/test_timeouts.h"
#include "base/threading/thread_restrictions.h"
@ -302,14 +301,12 @@ IN_PROC_BROWSER_TEST_F(ContentBrowserTest, NonNestableTask) {
IN_PROC_BROWSER_TEST_F(ContentBrowserTest, RunTimeoutInstalled) {
// Verify that a RunLoop timeout is installed and shorter than the test
// timeout itself.
const base::RunLoop::RunLoopTimeout* run_timeout =
base::test::ScopedRunLoopTimeout::GetTimeoutForCurrentThread();
const auto* run_timeout = base::RunLoop::ScopedRunTimeoutForTest::Current();
EXPECT_TRUE(run_timeout);
EXPECT_LT(run_timeout->timeout, TestTimeouts::test_launcher_timeout());
EXPECT_LT(run_timeout->timeout(), TestTimeouts::test_launcher_timeout());
static const base::RepeatingClosure& static_on_timeout =
run_timeout->on_timeout;
EXPECT_FATAL_FAILURE(static_on_timeout.Run(), "RunLoop::Run() timed out");
EXPECT_NONFATAL_FAILURE({ run_timeout->on_timeout().Run(); },
"RunLoop::Run() timed out");
}
} // namespace content

@ -691,10 +691,10 @@ Tests can run the `base::test::TaskEnvironment`'s message pump using a
`RunLoop::QuitClosure()`), or to `RunUntilIdle()` ready-to-run tasks and
immediately return.
TaskEnvironment configures RunLoop::Run() to GTEST_FAIL() if it hasn't been
TaskEnvironment configures RunLoop::Run() to LOG(FATAL) if it hasn't been
explicitly quit after TestTimeouts::action_timeout(). This is preferable to
having the test hang if the code under test fails to trigger the RunLoop to
quit. The timeout can be overridden with base::test::ScopedRunLoopTimeout.
quit. The timeout can be overridden with ScopedRunTimeoutForTest.
```cpp
class MyTest : public testing::Test {

@ -11,7 +11,6 @@
#include "base/callback_forward.h"
#include "base/hash/md5.h"
#include "base/run_loop.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/task_environment.h"
#include "media/audio/clockless_audio_sink.h"
#include "media/audio/null_audio_sink.h"
@ -159,7 +158,7 @@ class PipelineIntegrationTestBase : public Pipeline::Client {
bool fuzzing_;
#if defined(ADDRESS_SANITIZER) || defined(UNDEFINED_SANITIZER)
// TODO(https://crbug.com/924030): ASAN causes Run() timeouts to be reached.
const base::test::ScopedDisableRunLoopTimeout disable_run_timeout_;
const base::RunLoop::ScopedDisableRunTimeoutForTest disable_run_timeout_;
#endif
std::unique_ptr<Demuxer> demuxer_;
std::unique_ptr<DataSource> data_source_;

@ -20,6 +20,7 @@
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/bind_test_util.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/simple_test_tick_clock.h"
@ -779,8 +780,9 @@ TEST_F(ThroughputAnalyzerTest, TestThroughputWithNetworkRequestsOverlap) {
// of network requests overlap, and the minimum number of in flight requests
// when taking an observation is more than 1.
TEST_F(ThroughputAnalyzerTest, TestThroughputWithMultipleNetworkRequests) {
const base::test::ScopedRunLoopTimeout increased_run_timeout(
TestTimeouts::action_max_timeout());
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
TestTimeouts::action_max_timeout(),
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
const base::TickClock* tick_clock = base::DefaultTickClock::GetInstance();
TestNetworkQualityEstimator network_quality_estimator;

@ -226,11 +226,14 @@ class SimpleLoaderTestHelper : public SimpleURLLoaderStreamConsumer {
// StartSimpleLoaderAndWait, but exposed so some tests can start the
// SimpleURLLoader directly.
void Wait() {
const base::test::ScopedRunLoopTimeout run_timeout(
base::RunLoop::ScopedRunTimeoutForTest run_timeout(
// Some of the bots run tests quite slowly, and the default timeout is
// too short for them for some of the heavier weight tests.
// See https://crbug.com/1046745 and https://crbug.com/1035127.
TestTimeouts::action_max_timeout());
TestTimeouts::action_max_timeout(), base::BindLambdaForTesting([&]() {
ADD_FAILURE() << "Run loop timed out";
run_loop_.Quit();
}));
run_loop_.Run();
}

@ -35,7 +35,7 @@ include_rules = [
specific_include_rules = {
".*test.*": [
"+base/run_loop.h",
"+base/test/scoped_run_loop_timeout.h",
"+base/test/bind_test_util.h",
"+base/test/test_timeouts.h",
"+base/threading/thread.h",
"+media/audio/audio_sink_parameters.h",

@ -10,7 +10,7 @@
#include "base/memory/scoped_refptr.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/bind_test_util.h"
#include "base/test/test_timeouts.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
@ -261,7 +261,11 @@ class WebRtcMediaStreamTrackAdapterMapStressTest
: public WebRtcMediaStreamTrackAdapterMapTest {
public:
WebRtcMediaStreamTrackAdapterMapStressTest()
: increased_run_timeout_(TestTimeouts::action_max_timeout()) {}
: WebRtcMediaStreamTrackAdapterMapTest(),
increased_run_timeout_(
TestTimeouts::action_max_timeout(),
base::MakeExpectedNotRunClosure(FROM_HERE,
"RunLoop::Run() timed out.")) {}
void RunStressTest(size_t iterations) {
base::RunLoop run_loop;
@ -340,7 +344,7 @@ class WebRtcMediaStreamTrackAdapterMapStressTest
private:
// TODO(https://crbug.com/1002761): Fix this test to run in < action_timeout()
// on slower bots (e.g. Debug, ASAN, etc).
const base::test::ScopedRunLoopTimeout increased_run_timeout_;
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout_;
size_t remaining_iterations_;
};

@ -10,6 +10,7 @@
#include "base/bind.h"
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/test/bind_test_util.h"
#include "base/test/task_environment.h"
#include "base/test/test_simple_task_runner.h"
#include "base/test/test_timeouts.h"
@ -205,8 +206,9 @@ TEST_P(SnapshotAuraTest, MAYBE_FullScreenWindow) {
#if defined(OS_LINUX)
// TODO(https://crbug.com/1002716): Fix this test to run in < action_timeout()
// on the Linux Debug & TSAN bots.
const base::test::ScopedRunLoopTimeout increased_run_timeout(
TestTimeouts::action_max_timeout());
const base::RunLoop::ScopedRunTimeoutForTest increased_run_timeout(
TestTimeouts::action_max_timeout(),
base::MakeExpectedNotRunClosure(FROM_HERE, "RunLoop::Run() timed out."));
#endif // defined(OS_LINUX)
#if defined(OS_WIN)

@ -13,7 +13,6 @@
#include "base/power_monitor/power_monitor.h"
#include "base/power_monitor/power_monitor_device_source.h"
#include "base/run_loop.h"
#include "base/test/scoped_run_loop_timeout.h"
#include "base/test/task_environment.h"
#include "base/test/test_discardable_memory_allocator.h"
#include "base/test/test_timeouts.h"
@ -134,7 +133,7 @@ int main(int argc, char** argv) {
#endif
// This app isn't a test and shouldn't timeout.
base::test::ScopedDisableRunLoopTimeout disable_timeout;
base::RunLoop::ScopedDisableRunTimeoutForTest disable_timeout;
base::RunLoop run_loop;
views::examples::ShowExamplesWindow(run_loop.QuitClosure());