blob: 3759a5607d28141f7658a20311464628e482fbc6 [file] [log] [blame]
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/threading/post_task_and_reply_impl.h"
#include <utility>
#include "base/auto_reset.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "base/test/test_mock_time_task_runner.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::_;
namespace base::internal {
namespace {
class ObjectToDelete : public RefCounted<ObjectToDelete> {
public:
// `delete_flag` is set to true when this object is deleted
explicit ObjectToDelete(bool* delete_flag) : delete_flag_(delete_flag) {
EXPECT_FALSE(*delete_flag_);
}
ObjectToDelete(const ObjectToDelete&) = delete;
ObjectToDelete& operator=(const ObjectToDelete&) = delete;
private:
friend class RefCounted<ObjectToDelete>;
~ObjectToDelete() { *delete_flag_ = true; }
const raw_ptr<bool> delete_flag_;
};
class MockObject {
public:
MockObject() = default;
MockObject(const MockObject&) = delete;
MockObject& operator=(const MockObject&) = delete;
MOCK_METHOD1(Task, void(scoped_refptr<ObjectToDelete>));
MOCK_METHOD1(Reply, void(scoped_refptr<ObjectToDelete>));
WeakPtr<MockObject> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
void InvalidateWeakPtrs() { weak_factory_.InvalidateWeakPtrs(); }
private:
WeakPtrFactory<MockObject> weak_factory_{this};
};
class MockRunsTasksInCurrentSequenceTaskRunner : public TestMockTimeTaskRunner {
public:
explicit MockRunsTasksInCurrentSequenceTaskRunner(
TestMockTimeTaskRunner::Type type =
TestMockTimeTaskRunner::Type::kStandalone)
: TestMockTimeTaskRunner(type) {}
MockRunsTasksInCurrentSequenceTaskRunner(
const MockRunsTasksInCurrentSequenceTaskRunner&) = delete;
MockRunsTasksInCurrentSequenceTaskRunner& operator=(
const MockRunsTasksInCurrentSequenceTaskRunner&) = delete;
void StopAcceptingTasks() { accepts_tasks_ = false; }
void RunUntilIdleWithRunsTasksInCurrentSequence() {
AutoReset<bool> reset(&runs_tasks_in_current_sequence_, true);
RunUntilIdle();
}
void ClearPendingTasksWithRunsTasksInCurrentSequence() {
AutoReset<bool> reset(&runs_tasks_in_current_sequence_, true);
ClearPendingTasks();
}
// TestMockTimeTaskRunner:
bool RunsTasksInCurrentSequence() const override {
return runs_tasks_in_current_sequence_;
}
bool PostDelayedTask(const Location& from_here,
OnceClosure task,
TimeDelta delay) override {
if (!accepts_tasks_) {
return false;
}
return TestMockTimeTaskRunner::PostDelayedTask(from_here, std::move(task),
delay);
}
private:
~MockRunsTasksInCurrentSequenceTaskRunner() override = default;
bool accepts_tasks_ = true;
bool runs_tasks_in_current_sequence_ = false;
};
class PostTaskAndReplyImplTest : public testing::Test {
public:
PostTaskAndReplyImplTest(const PostTaskAndReplyImplTest&) = delete;
PostTaskAndReplyImplTest& operator=(const PostTaskAndReplyImplTest&) = delete;
protected:
PostTaskAndReplyImplTest() = default;
bool PostTaskAndReplyToMockObject(bool task_uses_weak_ptr = false) {
OnceClosure task;
if (task_uses_weak_ptr) {
task = BindOnce(&MockObject::Task, mock_object_.GetWeakPtr(),
MakeRefCounted<ObjectToDelete>(&delete_task_flag_));
} else {
task = BindOnce(&MockObject::Task, Unretained(&mock_object_),
MakeRefCounted<ObjectToDelete>(&delete_task_flag_));
}
return PostTaskAndReplyImpl(
[this](const Location& location, OnceClosure task) {
return post_runner_->PostTask(location, std::move(task));
},
FROM_HERE, std::move(task),
BindOnce(&MockObject::Reply, Unretained(&mock_object_),
MakeRefCounted<ObjectToDelete>(&delete_reply_flag_)));
}
void ExpectPostTaskAndReplyToMockObjectSucceeds(
bool task_uses_weak_ptr = false) {
// Expect the post to succeed.
EXPECT_TRUE(PostTaskAndReplyToMockObject(task_uses_weak_ptr));
// Expect the first task to be posted to `post_runner_`.
EXPECT_TRUE(post_runner_->HasPendingTask());
EXPECT_FALSE(reply_runner_->HasPendingTask());
EXPECT_FALSE(delete_task_flag_);
EXPECT_FALSE(delete_reply_flag_);
}
scoped_refptr<MockRunsTasksInCurrentSequenceTaskRunner> post_runner_ =
MakeRefCounted<MockRunsTasksInCurrentSequenceTaskRunner>();
scoped_refptr<MockRunsTasksInCurrentSequenceTaskRunner> reply_runner_ =
MakeRefCounted<MockRunsTasksInCurrentSequenceTaskRunner>(
TestMockTimeTaskRunner::Type::kBoundToThread);
testing::StrictMock<MockObject> mock_object_;
bool delete_task_flag_ = false;
bool delete_reply_flag_ = false;
};
} // namespace
TEST_F(PostTaskAndReplyImplTest, PostTaskAndReply) {
ExpectPostTaskAndReplyToMockObjectSucceeds();
EXPECT_CALL(mock_object_, Task(_));
post_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
testing::Mock::VerifyAndClear(&mock_object_);
// The task should have been deleted right after being run.
EXPECT_TRUE(delete_task_flag_);
EXPECT_FALSE(delete_reply_flag_);
// Expect the reply to be posted to `reply_runner_`.
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_TRUE(reply_runner_->HasPendingTask());
EXPECT_CALL(mock_object_, Reply(_));
reply_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
testing::Mock::VerifyAndClear(&mock_object_);
EXPECT_TRUE(delete_task_flag_);
// The reply should have been deleted right after being run.
EXPECT_TRUE(delete_reply_flag_);
// Expect no pending task in `post_runner_` and `reply_runner_`.
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_FALSE(reply_runner_->HasPendingTask());
}
TEST_F(PostTaskAndReplyImplTest, TaskDoesNotRun) {
ExpectPostTaskAndReplyToMockObjectSucceeds();
// Clear the `post_runner_`. Both callbacks should be scheduled for deletion
// on the `reply_runner_`.
post_runner_->ClearPendingTasksWithRunsTasksInCurrentSequence();
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_TRUE(reply_runner_->HasPendingTask());
EXPECT_FALSE(delete_task_flag_);
EXPECT_FALSE(delete_reply_flag_);
// Run the `reply_runner_`. Both callbacks should be deleted.
reply_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
EXPECT_TRUE(delete_task_flag_);
EXPECT_TRUE(delete_reply_flag_);
}
TEST_F(PostTaskAndReplyImplTest, ReplyDoesNotRun) {
ExpectPostTaskAndReplyToMockObjectSucceeds();
EXPECT_CALL(mock_object_, Task(_));
post_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
testing::Mock::VerifyAndClear(&mock_object_);
// The task should have been deleted right after being run.
EXPECT_TRUE(delete_task_flag_);
EXPECT_FALSE(delete_reply_flag_);
// Expect the reply to be posted to `reply_runner_`.
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_TRUE(reply_runner_->HasPendingTask());
// Clear the `reply_runner_` queue without running tasks. The reply callback
// should be deleted.
reply_runner_->ClearPendingTasksWithRunsTasksInCurrentSequence();
EXPECT_TRUE(delete_task_flag_);
EXPECT_TRUE(delete_reply_flag_);
}
// This is a regression test for crbug.com/922938.
TEST_F(PostTaskAndReplyImplTest,
PostTaskToStoppedTaskRunnerWithoutSequencedContext) {
reply_runner_.reset();
EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
post_runner_->StopAcceptingTasks();
// Expect the post to return false, but not to crash.
EXPECT_FALSE(PostTaskAndReplyToMockObject());
// Expect all tasks to be deleted.
EXPECT_TRUE(delete_task_flag_);
EXPECT_TRUE(delete_reply_flag_);
}
// Demonstrate that even if a task is not run because a weak pointer is
// invalidated, the reply still runs.
TEST_F(PostTaskAndReplyImplTest, ReplyStilRunsAfterInvalidatedWeakPtrTask) {
ExpectPostTaskAndReplyToMockObjectSucceeds(/*task_uses_weak_ptr=*/true);
// The task will not run when the provided weak pointer is invalidated.
EXPECT_CALL(mock_object_, Task(_)).Times(0);
mock_object_.InvalidateWeakPtrs();
post_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
testing::Mock::VerifyAndClear(&mock_object_);
// The task should have been deleted as part of dropping the run because of
// invalidated weak pointer.
EXPECT_TRUE(delete_task_flag_);
EXPECT_FALSE(delete_reply_flag_);
// Still expect a reply to be posted to `reply_runner_`.
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_TRUE(reply_runner_->HasPendingTask());
EXPECT_CALL(mock_object_, Reply(_)).Times(1);
reply_runner_->RunUntilIdleWithRunsTasksInCurrentSequence();
testing::Mock::VerifyAndClear(&mock_object_);
EXPECT_TRUE(delete_task_flag_);
// The reply should have been deleted right after being run.
EXPECT_TRUE(delete_reply_flag_);
// Expect no pending task in `post_runner_` and `reply_runner_`.
EXPECT_FALSE(post_runner_->HasPendingTask());
EXPECT_FALSE(reply_runner_->HasPendingTask());
}
} // namespace base::internal