after_startup_task_utils_unittest.cc 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "chrome/browser/after_startup_task_utils.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/memory/ref_counted.h"
  10. #include "base/run_loop.h"
  11. #include "base/task/sequenced_task_runner.h"
  12. #include "base/task/task_runner_util.h"
  13. #include "base/task/thread_pool.h"
  14. #include "base/test/bind.h"
  15. #include "content/public/browser/browser_task_traits.h"
  16. #include "content/public/browser/browser_thread.h"
  17. #include "content/public/test/browser_task_environment.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. namespace {
  20. class WrappedTaskRunner : public base::SequencedTaskRunner {
  21. public:
  22. explicit WrappedTaskRunner(scoped_refptr<SequencedTaskRunner> real_runner)
  23. : real_task_runner_(std::move(real_runner)) {}
  24. bool PostDelayedTask(const base::Location& from_here,
  25. base::OnceClosure task,
  26. base::TimeDelta delay) override {
  27. ++posted_task_count_;
  28. return real_task_runner_->PostDelayedTask(
  29. from_here,
  30. base::BindOnce(&WrappedTaskRunner::RunWrappedTask, this,
  31. std::move(task)),
  32. base::TimeDelta()); // Squash all delays so our tests complete asap.
  33. }
  34. bool PostNonNestableDelayedTask(const base::Location& from_here,
  35. base::OnceClosure task,
  36. base::TimeDelta delay) override {
  37. // Not implemented.
  38. NOTREACHED();
  39. return false;
  40. }
  41. bool RunsTasksInCurrentSequence() const override {
  42. return real_task_runner_->RunsTasksInCurrentSequence();
  43. }
  44. base::SequencedTaskRunner* real_runner() const {
  45. return real_task_runner_.get();
  46. }
  47. int total_task_count() const { return posted_task_count_ + ran_task_count_; }
  48. int posted_task_count() const { return posted_task_count_; }
  49. int ran_task_count() const { return ran_task_count_; }
  50. void reset_task_counts() {
  51. posted_task_count_ = 0;
  52. ran_task_count_ = 0;
  53. }
  54. private:
  55. ~WrappedTaskRunner() override {}
  56. void RunWrappedTask(base::OnceClosure task) {
  57. ++ran_task_count_;
  58. std::move(task).Run();
  59. }
  60. scoped_refptr<base::SequencedTaskRunner> real_task_runner_;
  61. int posted_task_count_ = 0;
  62. int ran_task_count_ = 0;
  63. };
  64. } // namespace
  65. class AfterStartupTaskTest : public testing::Test {
  66. public:
  67. AfterStartupTaskTest() {
  68. ui_thread_ = base::MakeRefCounted<WrappedTaskRunner>(
  69. content::GetUIThreadTaskRunner({}));
  70. background_sequence_ = base::MakeRefCounted<WrappedTaskRunner>(
  71. base::ThreadPool::CreateSequencedTaskRunner({}));
  72. AfterStartupTaskUtils::UnsafeResetForTesting();
  73. }
  74. // Hop to the background sequence and call IsBrowserStartupComplete.
  75. bool GetIsBrowserStartupCompleteFromBackgroundSequence() {
  76. base::RunLoop run_loop;
  77. bool is_complete;
  78. base::PostTaskAndReplyWithResult(
  79. background_sequence_->real_runner(), FROM_HERE,
  80. base::BindOnce(&AfterStartupTaskUtils::IsBrowserStartupComplete),
  81. base::BindOnce(&AfterStartupTaskTest::GotIsOnBrowserStartupComplete,
  82. &run_loop, &is_complete));
  83. run_loop.Run();
  84. return is_complete;
  85. }
  86. // Hop to the background sequence and call PostAfterStartupTask.
  87. void PostAfterStartupTaskFromBackgroundSequence(
  88. const base::Location& from_here,
  89. scoped_refptr<base::SequencedTaskRunner> task_runner,
  90. base::OnceClosure task) {
  91. base::RunLoop run_loop;
  92. background_sequence_->real_runner()->PostTaskAndReply(
  93. FROM_HERE,
  94. base::BindOnce(&AfterStartupTaskUtils::PostTask, from_here,
  95. std::move(task_runner), std::move(task)),
  96. base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
  97. run_loop.Run();
  98. }
  99. // Make sure all tasks posted to the background sequence get run.
  100. void FlushBackgroundSequence() {
  101. base::RunLoop run_loop;
  102. background_sequence_->real_runner()->PostTaskAndReply(
  103. FROM_HERE, base::DoNothing(),
  104. base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
  105. run_loop.Run();
  106. }
  107. static void VerifyExpectedSequence(base::SequencedTaskRunner* task_runner) {
  108. EXPECT_TRUE(task_runner->RunsTasksInCurrentSequence());
  109. }
  110. protected:
  111. scoped_refptr<WrappedTaskRunner> ui_thread_;
  112. scoped_refptr<WrappedTaskRunner> background_sequence_;
  113. private:
  114. static void GotIsOnBrowserStartupComplete(base::RunLoop* loop,
  115. bool* out,
  116. bool is_complete) {
  117. *out = is_complete;
  118. loop->Quit();
  119. }
  120. content::BrowserTaskEnvironment task_environment_;
  121. };
  122. TEST_F(AfterStartupTaskTest, IsStartupComplete) {
  123. // Check IsBrowserStartupComplete on a background sequence first to
  124. // verify that it does not allocate the underlying flag on that sequence.
  125. // That allocation sequence correctness part of this test relies on
  126. // the DCHECK in CancellationFlag::Set().
  127. EXPECT_FALSE(GetIsBrowserStartupCompleteFromBackgroundSequence());
  128. EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
  129. AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
  130. EXPECT_TRUE(AfterStartupTaskUtils::IsBrowserStartupComplete());
  131. EXPECT_TRUE(GetIsBrowserStartupCompleteFromBackgroundSequence());
  132. }
  133. TEST_F(AfterStartupTaskTest, PostTask) {
  134. // Nothing should be posted prior to startup completion.
  135. EXPECT_FALSE(AfterStartupTaskUtils::IsBrowserStartupComplete());
  136. AfterStartupTaskUtils::PostTask(
  137. FROM_HERE, ui_thread_,
  138. base::BindOnce(&AfterStartupTaskTest::VerifyExpectedSequence,
  139. base::RetainedRef(ui_thread_)));
  140. AfterStartupTaskUtils::PostTask(
  141. FROM_HERE, background_sequence_,
  142. base::BindOnce(&AfterStartupTaskTest::VerifyExpectedSequence,
  143. base::RetainedRef(background_sequence_)));
  144. PostAfterStartupTaskFromBackgroundSequence(
  145. FROM_HERE, ui_thread_,
  146. base::BindOnce(&AfterStartupTaskTest::VerifyExpectedSequence,
  147. base::RetainedRef(ui_thread_)));
  148. PostAfterStartupTaskFromBackgroundSequence(
  149. FROM_HERE, background_sequence_,
  150. base::BindOnce(&AfterStartupTaskTest::VerifyExpectedSequence,
  151. base::RetainedRef(background_sequence_)));
  152. base::RunLoop().RunUntilIdle();
  153. EXPECT_EQ(0, background_sequence_->total_task_count() +
  154. ui_thread_->total_task_count());
  155. // Queued tasks should be posted upon setting the flag.
  156. AfterStartupTaskUtils::SetBrowserStartupIsCompleteForTesting();
  157. EXPECT_EQ(2, background_sequence_->posted_task_count());
  158. EXPECT_EQ(2, ui_thread_->posted_task_count());
  159. FlushBackgroundSequence();
  160. base::RunLoop().RunUntilIdle();
  161. EXPECT_EQ(2, background_sequence_->ran_task_count());
  162. EXPECT_EQ(2, ui_thread_->ran_task_count());
  163. background_sequence_->reset_task_counts();
  164. ui_thread_->reset_task_counts();
  165. EXPECT_EQ(0, background_sequence_->total_task_count() +
  166. ui_thread_->total_task_count());
  167. // Tasks posted after startup should get posted immediately.
  168. AfterStartupTaskUtils::PostTask(FROM_HERE, ui_thread_, base::DoNothing());
  169. AfterStartupTaskUtils::PostTask(FROM_HERE, background_sequence_,
  170. base::DoNothing());
  171. EXPECT_EQ(1, background_sequence_->posted_task_count());
  172. EXPECT_EQ(1, ui_thread_->posted_task_count());
  173. PostAfterStartupTaskFromBackgroundSequence(FROM_HERE, ui_thread_,
  174. base::DoNothing());
  175. PostAfterStartupTaskFromBackgroundSequence(FROM_HERE, background_sequence_,
  176. base::DoNothing());
  177. EXPECT_EQ(2, background_sequence_->posted_task_count());
  178. EXPECT_EQ(2, ui_thread_->posted_task_count());
  179. FlushBackgroundSequence();
  180. base::RunLoop().RunUntilIdle();
  181. EXPECT_EQ(2, background_sequence_->ran_task_count());
  182. EXPECT_EQ(2, ui_thread_->ran_task_count());
  183. }