base/sequenced_task_runner_unittest.cc

   1 // Copyright 2016 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
   5 #include "base/sequenced_task_runner.h"
   6
   7 #include <utility>
   8
   9 #include "base/bind.h"
  10 #include "base/gtest_prod_util.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/task_environment.h"
  13 #include "base/threading/thread.h"
  14 #include "base/threading/thread_task_runner_handle.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace base {
  18 namespace {
  19
  20 class FlagOnDelete {
  21  public:
  22   FlagOnDelete(bool* deleted,
  23                scoped_refptr<SequencedTaskRunner> expected_deletion_sequence)
  24       : deleted_(deleted),
  25         expected_deletion_sequence_(std::move(expected_deletion_sequence)) {}
  26   FlagOnDelete(const FlagOnDelete&) = delete;
  27   FlagOnDelete& operator=(const FlagOnDelete&) = delete;
  28
  29  private:
  30   friend class DeleteHelper<FlagOnDelete>;
  31   FRIEND_TEST_ALL_PREFIXES(SequencedTaskRunnerTest,
  32                            OnTaskRunnerDeleterTargetStoppedEarly);
  33
  34   ~FlagOnDelete() {
  35     EXPECT_FALSE(*deleted_);
  36     *deleted_ = true;
  37     if (expected_deletion_sequence_)
  38       EXPECT_TRUE(expected_deletion_sequence_->RunsTasksInCurrentSequence());
  39   }
  40
  41   bool* deleted_;
  42   const scoped_refptr<SequencedTaskRunner> expected_deletion_sequence_;
  43 };
  44
  45 class SequencedTaskRunnerTest : public testing::Test {
  46  public:
  47   SequencedTaskRunnerTest(const SequencedTaskRunnerTest&) = delete;
  48   SequencedTaskRunnerTest& operator=(const SequencedTaskRunnerTest&) = delete;
  49
  50  protected:
  51   SequencedTaskRunnerTest() : foreign_thread_("foreign") {}
  52
  53   void SetUp() override {
  54     foreign_thread_.Start();
  55     foreign_runner_ = foreign_thread_.task_runner();
  56   }
  57
  58   scoped_refptr<SequencedTaskRunner> foreign_runner_;
  59
  60   Thread foreign_thread_;
  61
  62  private:
  63   test::TaskEnvironment task_environment_;
  64 };
  65
  66 using SequenceBoundUniquePtr =
  67     std::unique_ptr<FlagOnDelete, OnTaskRunnerDeleter>;
  68
  69 TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterOnMainThread) {
  70   bool deleted_on_main_thread = false;
  71   SequenceBoundUniquePtr ptr(
  72       new FlagOnDelete(&deleted_on_main_thread, ThreadTaskRunnerHandle::Get()),
  73       OnTaskRunnerDeleter(ThreadTaskRunnerHandle::Get()));
  74   EXPECT_FALSE(deleted_on_main_thread);
  75   foreign_runner_->PostTask(
  76       FROM_HERE, BindOnce([](SequenceBoundUniquePtr) {}, std::move(ptr)));
  77
  78   {
  79     RunLoop run_loop;
  80     foreign_runner_->PostTaskAndReply(FROM_HERE, BindOnce([] {}),
  81                                       run_loop.QuitClosure());
  82     run_loop.Run();
  83   }
  84   EXPECT_TRUE(deleted_on_main_thread);
  85 }
  86
  87 TEST_F(SequencedTaskRunnerTest, OnTaskRunnerDeleterTargetStoppedEarly) {
  88   bool deleted_on_main_thread = false;
  89   FlagOnDelete* raw =
  90       new FlagOnDelete(&deleted_on_main_thread, ThreadTaskRunnerHandle::Get());
  91   SequenceBoundUniquePtr ptr(raw, OnTaskRunnerDeleter(foreign_runner_));
  92   EXPECT_FALSE(deleted_on_main_thread);
  93
  94   // Stopping the target ahead of deleting |ptr| should make its
  95   // OnTaskRunnerDeleter no-op.
  96   foreign_thread_.Stop();
  97   ptr = nullptr;
  98   EXPECT_FALSE(deleted_on_main_thread);
  99
 100   delete raw;
 101   EXPECT_TRUE(deleted_on_main_thread);
 102 }
 103
 104 }  // namespace
 105 }  // namespace base