blob: 3caa00959f4a0d478ae7cc8daf78b6410c8b157c [file] [log] [blame]
// Copyright 2013 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/sequence_checker.h"
#include <stddef.h>
#include <memory>
#include <string>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/sequence_token.h"
#include "base/single_thread_task_runner.h"
#include "base/task/post_task.h"
#include "base/test/bind_test_util.h"
#include "base/test/gtest_util.h"
#include "base/test/scoped_task_environment.h"
#include "base/threading/simple_thread.h"
#include "base/threading/thread_local.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
// Runs a callback on another thread.
class RunCallbackThread : public SimpleThread {
public:
explicit RunCallbackThread(OnceClosure callback)
: SimpleThread("RunCallbackThread"), callback_(std::move(callback)) {
Start();
Join();
}
private:
// SimpleThread:
void Run() override { std::move(callback_).Run(); }
OnceClosure callback_;
DISALLOW_COPY_AND_ASSIGN(RunCallbackThread);
};
void ExpectCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
ASSERT_TRUE(sequence_checker);
// This should bind |sequence_checker| to the current sequence if it wasn't
// already bound to a sequence.
EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
// Since |sequence_checker| is now bound to the current sequence, another call
// to CalledOnValidSequence() should return true.
EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
}
void ExpectCalledOnValidSequenceWithSequenceToken(
SequenceCheckerImpl* sequence_checker,
SequenceToken sequence_token) {
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(sequence_token);
ExpectCalledOnValidSequence(sequence_checker);
}
void ExpectNotCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
ASSERT_TRUE(sequence_checker);
EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
}
} // namespace
TEST(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) {
SequenceCheckerImpl sequence_checker;
EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) {
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
SequenceCheckerImpl sequence_checker;
EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) {
SequenceCheckerImpl sequence_checker;
RunCallbackThread thread(
BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)));
}
TEST(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) {
const SequenceToken sequence_token(SequenceToken::Create());
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(sequence_token);
SequenceCheckerImpl sequence_checker;
EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
RunCallbackThread thread(
BindOnce(&ExpectCalledOnValidSequenceWithSequenceToken,
Unretained(&sequence_checker), sequence_token));
}
TEST(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) {
std::unique_ptr<SequenceCheckerImpl> sequence_checker;
{
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
sequence_checker.reset(new SequenceCheckerImpl);
}
{
// Different SequenceToken.
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
}
// No SequenceToken.
EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
}
TEST(SequenceCheckerTest, DetachFromSequence) {
std::unique_ptr<SequenceCheckerImpl> sequence_checker;
{
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
sequence_checker.reset(new SequenceCheckerImpl);
}
sequence_checker->DetachFromSequence();
{
// Verify that CalledOnValidSequence() returns true when called with
// a different sequence token after a call to DetachFromSequence().
ScopedSetSequenceTokenForCurrentThread
scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
}
}
TEST(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) {
SequenceCheckerImpl sequence_checker;
sequence_checker.DetachFromSequence();
// Verify that CalledOnValidSequence() returns true when called on a
// different thread after a call to DetachFromSequence().
RunCallbackThread thread(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)));
EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, Move) {
SequenceCheckerImpl initial;
EXPECT_TRUE(initial.CalledOnValidSequence());
SequenceCheckerImpl move_constructed(std::move(initial));
EXPECT_TRUE(move_constructed.CalledOnValidSequence());
SequenceCheckerImpl move_assigned;
move_assigned = std::move(move_constructed);
// The two SequenceCheckerImpls moved from should be able to rebind to another
// sequence.
RunCallbackThread thread1(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
RunCallbackThread thread2(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&move_constructed)));
// But the latest one shouldn't be able to run on another sequence.
RunCallbackThread thread(
BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&move_assigned)));
EXPECT_TRUE(move_assigned.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, MoveAssignIntoDetached) {
SequenceCheckerImpl initial;
SequenceCheckerImpl move_assigned;
move_assigned.DetachFromSequence();
move_assigned = std::move(initial);
// |initial| is detached after move.
RunCallbackThread thread1(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
// |move_assigned| should be associated with the main thread.
RunCallbackThread thread2(
BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&move_assigned)));
EXPECT_TRUE(move_assigned.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, MoveFromDetachedRebinds) {
SequenceCheckerImpl initial;
initial.DetachFromSequence();
SequenceCheckerImpl moved_into(std::move(initial));
// |initial| is still detached after move.
RunCallbackThread thread1(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
// |moved_into| is bound to the current sequence as part of the move.
RunCallbackThread thread2(
BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&moved_into)));
EXPECT_TRUE(moved_into.CalledOnValidSequence());
}
TEST(SequenceCheckerTest, MoveOffSequenceBanned) {
testing::GTEST_FLAG(death_test_style) = "threadsafe";
SequenceCheckerImpl other_sequence;
other_sequence.DetachFromSequence();
RunCallbackThread thread(
BindOnce(&ExpectCalledOnValidSequence, Unretained(&other_sequence)));
EXPECT_DCHECK_DEATH(
SequenceCheckerImpl main_sequence(std::move(other_sequence)));
}
TEST(SequenceCheckerMacroTest, Macros) {
auto scope = std::make_unique<ScopedSetSequenceTokenForCurrentThread>(
SequenceToken::Create());
SEQUENCE_CHECKER(my_sequence_checker);
// Don't expect a DCHECK death when a SequenceChecker is used on the right
// sequence.
DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
scope.reset();
#if DCHECK_IS_ON()
// Expect DCHECK death when used on a different sequence.
EXPECT_DCHECK_DEATH({
DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
});
#else
// Happily no-ops on non-dcheck builds.
DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
#endif
DETACH_FROM_SEQUENCE(my_sequence_checker);
// Don't expect a DCHECK death when a SequenceChecker is used for the first
// time after having been detached.
DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker) << "Error message.";
}
// Owns a SequenceCheckerImpl, and asserts that CalledOnValidSequence() is valid
// in ~SequenceCheckerOwner.
class SequenceCheckerOwner {
public:
SequenceCheckerOwner() = default;
~SequenceCheckerOwner() { EXPECT_TRUE(checker_.CalledOnValidSequence()); }
private:
SequenceCheckerImpl checker_;
DISALLOW_COPY_AND_ASSIGN(SequenceCheckerOwner);
};
// Verifies SequenceCheckerImpl::CalledOnValidSequence() returns true if called
// during thread destruction.
TEST(SequenceCheckerTest, CalledOnValidSequenceFromThreadDestruction) {
ThreadLocalOwnedPointer<SequenceCheckerOwner> thread_local_owner;
{
test::TaskEnvironment task_environment;
auto task_runner = CreateSequencedTaskRunner({ThreadPool()});
task_runner->PostTask(
FROM_HERE, BindLambdaForTesting([&]() {
thread_local_owner.Set(std::make_unique<SequenceCheckerOwner>());
}));
task_runner = nullptr;
task_environment.RunUntilIdle();
}
}
} // namespace base