Revert "Implement base::GetContinuationTaskRunner()."
This reverts commit 0dd49956177733fd57fa1698e357ee83f6074494.
Reason for revert:
Remove the ability to get the current task runner according to
the recent discussions in scheduler-dev@ [1].
[1] https://docs.google.com/document/d/1tssusPykvx3g0gvbvU4HxGyn3MjJlIylnsH13-Tv6s4/edit
[email protected],[email protected],[email protected]
BUG=1026641
Original change's description:
> Implement base::GetContinuationTaskRunner().
>
> This returns to the current task's task runner. Note there are some
> situations where this is not valid:
>
> * When we're not running a task (it will DCHECK).
> * When we're in a one-off base::ThreadPool task (it will DCHECK).
> * In non-scheduler backed threads (it will DCHECK).
>
> Bug: 835323
> Change-Id: I3a789557247240e0c36a47339574350d79746144
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1834094
> Commit-Queue: Gabriel Charette <[email protected]>
> Reviewed-by: Gabriel Charette <[email protected]>
> Reviewed-by: Rohit Rao <[email protected]>
> Reviewed-by: François Doray <[email protected]>
> Cr-Commit-Position: refs/heads/master@{#707484}
[email protected],[email protected],[email protected],[email protected]
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: 835323
Change-Id: I233ff3ba4e2f20e23a67a3bf6c46734608144eca
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1959917
Reviewed-by: Alexander Timin <[email protected]>
Reviewed-by: Gabriel Charette <[email protected]>
Commit-Queue: Alexander Timin <[email protected]>
Cr-Commit-Position: refs/heads/master@{#728982}
diff --git a/base/task/post_task.cc b/base/task/post_task.cc
index dce2f96..244e5f6 100644
--- a/base/task/post_task.cc
+++ b/base/task/post_task.cc
@@ -146,17 +146,4 @@
}
#endif // defined(OS_WIN)
-const scoped_refptr<SequencedTaskRunner>& GetContinuationTaskRunner() {
- TaskExecutor* executor = GetTaskExecutorForCurrentThread();
- DCHECK(executor) << "Couldn't find a TaskExecutor for this thread. Note "
- "you can't use base::GetContinuationTaskRunner in "
- "a one-off base::ThreadPool task.";
- const auto& task_runner = executor->GetContinuationTaskRunner();
- DCHECK(task_runner)
- << "The current execution context lacks a continuation task runner. "
- "Note: you can't use base::GetContinuationTaskRunner() from a native "
- "system event or any other context outside of a Chrome task.";
- return task_runner;
-}
-
} // namespace base
diff --git a/base/task/post_task.h b/base/task/post_task.h
index 3de95ec..4579cbff 100644
--- a/base/task/post_task.h
+++ b/base/task/post_task.h
@@ -51,13 +51,6 @@
// task_runner->PostTask(FROM_HERE, BindOnce(...));
// task_runner->PostTask(FROM_HERE, BindOnce(...));
//
-// To post a task on the current thread or sequence but with an explicit
-// priority:
-// PostTask(FROM_HERE,
-// {CurrentThread(), TaskPriority::BEST_EFFORT},
-// BindOnce(...));
-//
-//
// The default traits apply to tasks that:
// (1) don't block (ref. MayBlock() and WithBaseSyncPrimitives()),
// (2) prefer inheriting the current priority to specifying their own, and
@@ -239,15 +232,6 @@
SingleThreadTaskRunnerThreadMode::SHARED);
#endif // defined(OS_WIN)
-// Returns: The SequencedTaskRunner for the currently executing task, if any.
-// Otherwise it returns a null scoped_refptr. On threads where there's no
-// TaskExecutor registered this will DCHECK e.g. in a one-off ThreadPool task.
-//
-// Experimental: Further discussions are in progress for this API. Please
-// continue using SequencedTaskRunnerHandle::Get() in the mean time.
-BASE_EXPORT const scoped_refptr<SequencedTaskRunner>&
-GetContinuationTaskRunner();
-
// Helpers to send a Delete/ReleaseSoon to a new SequencedTaskRunner created
// from |traits|. The semantics match base::PostTask in that the deletion is
// guaranteed to be scheduled in order with other tasks using the same |traits|.
diff --git a/base/task/post_task_unittest.cc b/base/task/post_task_unittest.cc
index c1c9ac90..2130a8f 100644
--- a/base/task/post_task_unittest.cc
+++ b/base/task/post_task_unittest.cc
@@ -73,9 +73,6 @@
SingleThreadTaskRunnerThreadMode thread_mode));
#endif // defined(OS_WIN)
- MOCK_METHOD0(GetContinuationTaskRunner,
- const scoped_refptr<SequencedTaskRunner>&());
-
TestSimpleTaskRunner* runner() const { return runner_.get(); }
private:
@@ -282,49 +279,6 @@
run_loop.Run();
}
-TEST_F(PostTaskTestWithExecutor, TaskRunnerTaskGetContinuationTaskRunner) {
- auto task_runner = CreateTaskRunner({ThreadPool()});
- RunLoop run_loop;
-
- EXPECT_TRUE(task_runner->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
- // GetContinuationTaskRunner is
- // meaningless in this context.
- EXPECT_DCHECK_DEATH(
- GetContinuationTaskRunner());
- run_loop.Quit();
- })));
-
- run_loop.Run();
-}
-
-TEST_F(PostTaskTestWithExecutor,
- SequencedTaskRunnerTaskGetContinuationTaskRunner) {
- auto sequenced_task_runner = CreateSequencedTaskRunner({ThreadPool()});
- RunLoop run_loop;
-
- EXPECT_TRUE(sequenced_task_runner->PostTask(
- FROM_HERE, BindLambdaForTesting([&]() {
- EXPECT_EQ(GetContinuationTaskRunner(), sequenced_task_runner);
- run_loop.Quit();
- })));
-
- run_loop.Run();
-}
-
-TEST_F(PostTaskTestWithExecutor,
- SingleThreadTaskRunnerTaskGetContinuationTaskRunner) {
- auto single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()});
- RunLoop run_loop;
-
- EXPECT_TRUE(single_thread_task_runner->PostTask(
- FROM_HERE, BindLambdaForTesting([&]() {
- EXPECT_EQ(GetContinuationTaskRunner(), single_thread_task_runner);
- run_loop.Quit();
- })));
-
- run_loop.Run();
-}
-
TEST_F(PostTaskTestWithExecutor, ThreadPoolCurrentThreadChangePriority) {
auto single_thread_task_runner =
CreateSingleThreadTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING});
diff --git a/base/task/sequence_manager/sequence_manager.h b/base/task/sequence_manager/sequence_manager.h
index 13cebbb..9710bf8f 100644
--- a/base/task/sequence_manager/sequence_manager.h
+++ b/base/task/sequence_manager/sequence_manager.h
@@ -144,8 +144,7 @@
// Returns the task runner the current task was posted on. Returns null if no
// task is currently running. Must be called on the bound thread.
- virtual const scoped_refptr<SequencedTaskRunner>&
- GetTaskRunnerForCurrentTask() = 0;
+ virtual scoped_refptr<SequencedTaskRunner> GetTaskRunnerForCurrentTask() = 0;
// Finishes the initialization for a SequenceManager created via
// CreateUnboundSequenceManager(). Must not be called in any other
diff --git a/base/task/sequence_manager/sequence_manager_impl.cc b/base/task/sequence_manager/sequence_manager_impl.cc
index 616944f..fcdb8d1 100644
--- a/base/task/sequence_manager/sequence_manager_impl.cc
+++ b/base/task/sequence_manager/sequence_manager_impl.cc
@@ -42,12 +42,6 @@
return lazy_tls_ptr.get();
}
-const scoped_refptr<SequencedTaskRunner>& GetNullTaskRunner() {
- static const base::NoDestructor<scoped_refptr<SequencedTaskRunner>>
- null_task_runner;
- return *null_task_runner;
-}
-
} // namespace
// This controls how big the the initial for
@@ -340,11 +334,11 @@
BindToMessagePump(std::move(pump));
}
-const scoped_refptr<SequencedTaskRunner>&
+scoped_refptr<SequencedTaskRunner>
SequenceManagerImpl::GetTaskRunnerForCurrentTask() {
DCHECK_CALLED_ON_VALID_THREAD(associated_thread_->thread_checker);
if (main_thread_only().task_execution_stack.empty())
- return GetNullTaskRunner();
+ return nullptr;
return main_thread_only()
.task_execution_stack.back()
.pending_task.task_runner;
diff --git a/base/task/sequence_manager/sequence_manager_impl.h b/base/task/sequence_manager/sequence_manager_impl.h
index bd3babc..37141b7 100644
--- a/base/task/sequence_manager/sequence_manager_impl.h
+++ b/base/task/sequence_manager/sequence_manager_impl.h
@@ -102,8 +102,7 @@
// SequenceManager implementation:
void BindToCurrentThread() override;
- const scoped_refptr<SequencedTaskRunner>& GetTaskRunnerForCurrentTask()
- override;
+ scoped_refptr<SequencedTaskRunner> GetTaskRunnerForCurrentTask() override;
void BindToMessagePump(std::unique_ptr<MessagePump> message_pump) override;
void SetObserver(Observer* observer) override;
void AddTaskTimeObserver(TaskTimeObserver* task_time_observer) override;
diff --git a/base/task/simple_task_executor.cc b/base/task/simple_task_executor.cc
index c4d7d2f..ffccf52 100644
--- a/base/task/simple_task_executor.cc
+++ b/base/task/simple_task_executor.cc
@@ -4,16 +4,11 @@
#include "base/task/simple_task_executor.h"
-#include "base/task/sequence_manager/sequence_manager.h"
-
namespace base {
SimpleTaskExecutor::SimpleTaskExecutor(
- sequence_manager::SequenceManager* sequence_manager,
scoped_refptr<SingleThreadTaskRunner> task_queue)
- : sequence_manager_(sequence_manager),
- sequenced_task_queue_(task_queue),
- task_queue_(std::move(task_queue)),
+ : task_queue_(std::move(task_queue)),
previous_task_executor_(GetTaskExecutorForCurrentThread()) {
DCHECK(task_queue_);
// The TaskExecutor API does not expect nesting, but this can happen in tests
@@ -43,7 +38,7 @@
scoped_refptr<SequencedTaskRunner>
SimpleTaskExecutor::CreateSequencedTaskRunner(const TaskTraits& traits) {
- return sequenced_task_queue_;
+ return task_queue_;
}
scoped_refptr<SingleThreadTaskRunner>
@@ -64,11 +59,4 @@
}
#endif // defined(OS_WIN)
-const scoped_refptr<SequencedTaskRunner>&
-SimpleTaskExecutor::GetContinuationTaskRunner() {
- if (sequence_manager_)
- return sequence_manager_->GetTaskRunnerForCurrentTask();
- return sequenced_task_queue_;
-}
-
} // namespace base
diff --git a/base/task/simple_task_executor.h b/base/task/simple_task_executor.h
index be6531f..7d9a74dc 100644
--- a/base/task/simple_task_executor.h
+++ b/base/task/simple_task_executor.h
@@ -9,19 +9,13 @@
#include "build/build_config.h"
namespace base {
-namespace sequence_manager {
-class SequenceManager;
-} // namespace sequence_manager
// A simple TaskExecutor with exactly one SingleThreadTaskRunner.
// Must be instantiated and destroyed on the thread that runs tasks for the
// SingleThreadTaskRunner.
class BASE_EXPORT SimpleTaskExecutor : public TaskExecutor {
public:
- // If |sequence_manager| is null, GetContinuationTaskRunner will always return
- // |task_queue| even if no task is running.
- SimpleTaskExecutor(sequence_manager::SequenceManager* sequence_manager,
- scoped_refptr<SingleThreadTaskRunner> task_queue);
+ explicit SimpleTaskExecutor(scoped_refptr<SingleThreadTaskRunner> task_queue);
~SimpleTaskExecutor() override;
@@ -45,12 +39,7 @@
SingleThreadTaskRunnerThreadMode thread_mode) override;
#endif // defined(OS_WIN)
- const scoped_refptr<SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
-
- protected:
- sequence_manager::SequenceManager* const sequence_manager_;
- const scoped_refptr<SequencedTaskRunner> sequenced_task_queue_;
+ private:
const scoped_refptr<SingleThreadTaskRunner> task_queue_;
// In tests there may already be a TaskExecutor registered for the thread, we
diff --git a/base/task/single_thread_task_executor.cc b/base/task/single_thread_task_executor.cc
index c88435a..3014bde 100644
--- a/base/task/single_thread_task_executor.cc
+++ b/base/task/single_thread_task_executor.cc
@@ -31,7 +31,7 @@
default_task_queue_(sequence_manager_->CreateTaskQueue(
sequence_manager::TaskQueue::Spec("default_tq"))),
type_(type),
- simple_task_executor_(sequence_manager_.get(), task_runner()) {
+ simple_task_executor_(task_runner()) {
sequence_manager_->SetDefaultTaskRunner(default_task_queue_->task_runner());
sequence_manager_->BindToMessagePump(std::move(pump));
}
diff --git a/base/task/single_thread_task_executor_unittest.cc b/base/task/single_thread_task_executor_unittest.cc
index b69bbf3cb..b64294f 100644
--- a/base/task/single_thread_task_executor_unittest.cc
+++ b/base/task/single_thread_task_executor_unittest.cc
@@ -7,7 +7,6 @@
#include "base/run_loop.h"
#include "base/task/post_task.h"
#include "base/test/bind_test_util.h"
-#include "base/test/gtest_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -56,24 +55,4 @@
{base::CurrentThread(), base::TaskPriority::BEST_EFFORT}));
}
-TEST(SingleThreadTaskExecutorTest, GetContinuationTaskRunner) {
- SingleThreadTaskExecutor single_thread_task_executor;
- RunLoop run_loop;
-
- auto task_runner = CreateSingleThreadTaskRunner({CurrentThread()});
-
- task_runner->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
- EXPECT_EQ(task_runner, GetContinuationTaskRunner());
- run_loop.Quit();
- }));
-
- run_loop.Run();
-}
-
-TEST(SingleThreadTaskExecutorTest, GetCurrentTaskWithNoTaskRunning) {
- SingleThreadTaskExecutor single_thread_task_executor;
-
- EXPECT_DCHECK_DEATH(GetContinuationTaskRunner());
-}
-
} // namespace base
diff --git a/base/task/task_executor.h b/base/task/task_executor.h
index 77debc9..a062fdc 100644
--- a/base/task/task_executor.h
+++ b/base/task/task_executor.h
@@ -63,11 +63,6 @@
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode) = 0;
#endif // defined(OS_WIN)
-
- // Returns the sequence the current task was posted on, if any, or null
- // otherwise (e.g. for parallel tasks).
- virtual const scoped_refptr<SequencedTaskRunner>&
- GetContinuationTaskRunner() = 0;
};
// Register a TaskExecutor with the //base/task/post_task.h API in the current
diff --git a/base/task/thread_pool/task_tracker.cc b/base/task/thread_pool/task_tracker.cc
index a324d21..ea1a9c8 100644
--- a/base/task/thread_pool/task_tracker.cc
+++ b/base/task/thread_pool/task_tracker.cc
@@ -138,20 +138,18 @@
switches::kLogBestEffortTasks);
}
-// Needed for GetContinuationTaskRunner and CurrentThread. This executor lives
-// for the duration of a threadpool task invocation.
+// Needed for PostTaskHere and CurrentThread. This executor lives for the
+// duration of a threadpool task invocation.
class EphemeralTaskExecutor : public TaskExecutor {
public:
// |sequenced_task_runner| and |single_thread_task_runner| must outlive this
- // EphemeralTaskExecutor. Note |single_thread_task_runner| may be null.
- EphemeralTaskExecutor(
- scoped_refptr<SequencedTaskRunner> sequenced_task_runner,
- SingleThreadTaskRunner* single_thread_task_runner,
- const TaskTraits* sequence_traits)
- : sequenced_task_runner_(std::move(sequenced_task_runner)),
+ // EphemeralTaskExecutor.
+ EphemeralTaskExecutor(SequencedTaskRunner* sequenced_task_runner,
+ SingleThreadTaskRunner* single_thread_task_runner,
+ const TaskTraits* sequence_traits)
+ : sequenced_task_runner_(sequenced_task_runner),
single_thread_task_runner_(single_thread_task_runner),
sequence_traits_(sequence_traits) {
- DCHECK(sequenced_task_runner_);
SetTaskExecutorForCurrentThread(this);
}
@@ -197,11 +195,6 @@
}
#endif // defined(OS_WIN)
- const scoped_refptr<SequencedTaskRunner>& GetContinuationTaskRunner()
- override {
- return sequenced_task_runner_;
- }
-
private:
// Currently ignores |traits.priority()|.
void CheckTraitsCompatibleWithSequenceTraits(const TaskTraits& traits) {
@@ -218,7 +211,7 @@
sequence_traits_->with_base_sync_primitives());
}
- const scoped_refptr<SequencedTaskRunner> sequenced_task_runner_;
+ SequencedTaskRunner* const sequenced_task_runner_;
SingleThreadTaskRunner* const single_thread_task_runner_;
const TaskTraits* const sequence_traits_;
};
diff --git a/base/task/thread_pool/thread_pool_impl.cc b/base/task/thread_pool/thread_pool_impl.cc
index 7e49ee8..a56552a 100644
--- a/base/task/thread_pool/thread_pool_impl.cc
+++ b/base/task/thread_pool/thread_pool_impl.cc
@@ -61,12 +61,6 @@
switches::kDisableBestEffortTasks);
}
-const scoped_refptr<SequencedTaskRunner>& GetNullTaskRunner() {
- static const NoDestructor<scoped_refptr<SequencedTaskRunner>>
- null_task_runner;
- return *null_task_runner;
-}
-
} // namespace
ThreadPoolImpl::ThreadPoolImpl(StringPiece histogram_label)
@@ -279,14 +273,6 @@
return MakeRefCounted<PooledSequencedTaskRunner>(new_traits, this);
}
-const scoped_refptr<SequencedTaskRunner>&
-ThreadPoolImpl::GetContinuationTaskRunner() {
- // Default to null for parallel tasks; see task_tracker.cc's
- // EphemeralTaskExecutor for how sequenced contexts handle this.
- NOTREACHED();
- return GetNullTaskRunner();
-}
-
Optional<TimeTicks> ThreadPoolImpl::NextScheduledRunTimeForTesting() const {
if (task_tracker_->HasIncompleteTaskSourcesForTesting())
return TimeTicks::Now();
diff --git a/base/task/thread_pool/thread_pool_impl.h b/base/task/thread_pool/thread_pool_impl.h
index b4cfc49ac..82c76a2 100644
--- a/base/task/thread_pool/thread_pool_impl.h
+++ b/base/task/thread_pool/thread_pool_impl.h
@@ -100,8 +100,6 @@
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode) override;
#endif // defined(OS_WIN)
- const scoped_refptr<SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
scoped_refptr<UpdateableSequencedTaskRunner>
CreateUpdateableSequencedTaskRunner(const TaskTraits& traits);
diff --git a/base/test/task_environment.cc b/base/test/task_environment.cc
index 80a85e2..2f730e6 100644
--- a/base/test/task_environment.cc
+++ b/base/test/task_environment.cc
@@ -403,8 +403,7 @@
.SetTimeDomain(mock_time_domain_.get()));
task_runner_ = task_queue_->task_runner();
sequence_manager_->SetDefaultTaskRunner(task_runner_);
- simple_task_executor_ = std::make_unique<SimpleTaskExecutor>(
- sequence_manager_.get(), task_runner_);
+ simple_task_executor_ = std::make_unique<SimpleTaskExecutor>(task_runner_);
CHECK(base::ThreadTaskRunnerHandle::IsSet())
<< "ThreadTaskRunnerHandle should've been set now.";
CompleteInitialization();
diff --git a/base/test/task_environment.h b/base/test/task_environment.h
index daae7d6c..01d19d9 100644
--- a/base/test/task_environment.h
+++ b/base/test/task_environment.h
@@ -36,7 +36,7 @@
// This header exposes SingleThreadTaskEnvironment and TaskEnvironment.
//
// SingleThreadTaskEnvironment enables the following APIs within its scope:
-// - ThreadTaskRunnerHandle & GetContinuationTaskRunner on the main thread
+// - (Thread|Sequenced)TaskRunnerHandle on the main thread
// - RunLoop on the main thread
//
// TaskEnvironment additionally enables:
@@ -47,7 +47,7 @@
// Tests should prefer SingleThreadTaskEnvironment over TaskEnvironment when the
// former is sufficient.
//
-// Tasks posted to the APIs listed above run synchronously when
+// Tasks posted to the (Thread|Sequenced)TaskRunnerHandle run synchronously when
// RunLoop::Run(UntilIdle) or TaskEnvironment::RunUntilIdle is called on the
// main thread.
//
@@ -185,7 +185,7 @@
trait_helpers::NotATraitTag()) {}
// Waits until no undelayed ThreadPool tasks remain. Then, unregisters the
- // ThreadPoolInstance and the APIs listed in the top level comment.
+ // ThreadPoolInstance and the (Thread|Sequenced)TaskRunnerHandle.
virtual ~TaskEnvironment();
// Returns a TaskRunner that schedules tasks on the main thread.
@@ -195,11 +195,11 @@
// always return true if called right after RunUntilIdle.
bool MainThreadIsIdle() const;
- // Runs tasks until both the APIs listed in the top level comment and the
- // ThreadPool's non-delayed queues are empty. While RunUntilIdle() is quite
- // practical and sometimes even necessary -- for example, to flush all tasks
- // bound to Unretained() state before destroying test members -- it should be
- // used with caution per the following warnings:
+ // Runs tasks until both the (Thread|Sequenced)TaskRunnerHandle and the
+ // ThreadPool's non-delayed queues are empty.
+ // While RunUntilIdle() is quite practical and sometimes even necessary -- for
+ // example, to flush all tasks bound to Unretained() state before destroying
+ // test members -- it should be used with caution per the following warnings:
//
// WARNING #1: This may run long (flakily timeout) and even never return! Do
// not use this when repeating tasks such as animated web pages
diff --git a/base/test/task_environment_unittest.cc b/base/test/task_environment_unittest.cc
index 03b35465..e6a929e 100644
--- a/base/test/task_environment_unittest.cc
+++ b/base/test/task_environment_unittest.cc
@@ -1199,23 +1199,5 @@
run_loop.Run();
}
-TEST_F(TaskEnvironmentTest, GetContinuationTaskRunner) {
- SingleThreadTaskEnvironment task_environment;
- RunLoop run_loop;
- auto task_runner = CreateSingleThreadTaskRunner({CurrentThread()});
-
- task_runner->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
- EXPECT_EQ(task_runner, GetContinuationTaskRunner());
- run_loop.Quit();
- }));
-
- run_loop.Run();
-}
-
-TEST_F(TaskEnvironmentTest, GetContinuationTaskRunnerWithNoTaskRunning) {
- SingleThreadTaskEnvironment task_environment;
- EXPECT_DCHECK_DEATH(GetContinuationTaskRunner());
-}
-
} // namespace test
} // namespace base
diff --git a/base/threading/thread.cc b/base/threading/thread.cc
index 093d8842..eecd3491 100644
--- a/base/threading/thread.cc
+++ b/base/threading/thread.cc
@@ -87,8 +87,7 @@
sequence_manager_->BindToMessagePump(
std::move(message_pump_factory_).Run());
sequence_manager_->SetTimerSlack(timer_slack);
- simple_task_executor_.emplace(sequence_manager_.get(),
- GetDefaultTaskRunner());
+ simple_task_executor_.emplace(GetDefaultTaskRunner());
}
private:
diff --git a/content/browser/scheduler/browser_io_thread_delegate.cc b/content/browser/scheduler/browser_io_thread_delegate.cc
index 5f13084..cac4e866 100644
--- a/content/browser/scheduler/browser_io_thread_delegate.cc
+++ b/content/browser/scheduler/browser_io_thread_delegate.cc
@@ -112,10 +112,4 @@
}
}
-const scoped_refptr<base::SequencedTaskRunner>&
-BrowserIOThreadDelegate::GetTaskRunnerForCurrentTask() const {
- DCHECK(sequence_manager_);
- return sequence_manager_->GetTaskRunnerForCurrentTask();
-}
-
} // namespace content
diff --git a/content/browser/scheduler/browser_io_thread_delegate.h b/content/browser/scheduler/browser_io_thread_delegate.h
index 69699369..0954c5e 100644
--- a/content/browser/scheduler/browser_io_thread_delegate.h
+++ b/content/browser/scheduler/browser_io_thread_delegate.h
@@ -55,10 +55,6 @@
scoped_refptr<Handle> GetHandle() { return task_queues_->GetHandle(); }
- // Must be called on the IO thread.
- const scoped_refptr<base::SequencedTaskRunner>& GetTaskRunnerForCurrentTask()
- const;
-
private:
class TLSMultiplexer;
diff --git a/content/browser/scheduler/browser_task_executor.cc b/content/browser/scheduler/browser_task_executor.cc
index 3f8a9f2..ec6b138 100644
--- a/content/browser/scheduler/browser_task_executor.cc
+++ b/content/browser/scheduler/browser_task_executor.cc
@@ -65,12 +65,6 @@
}
}
-const scoped_refptr<base::SequencedTaskRunner>& GetNullTaskRunner() {
- static const base::NoDestructor<scoped_refptr<base::SequencedTaskRunner>>
- null_task_runner;
- return *null_task_runner;
-}
-
} // namespace
BaseBrowserTaskExecutor::BaseBrowserTaskExecutor() = default;
@@ -398,13 +392,6 @@
return BrowserThread::UI;
}
-const scoped_refptr<base::SequencedTaskRunner>&
-BrowserTaskExecutor::GetContinuationTaskRunner() {
- NOTREACHED()
- << "Should have been routed to UIThreadExecutor or IOThreadExecutor";
- return GetNullTaskRunner();
-}
-
BrowserTaskExecutor::UIThreadExecutor::UIThreadExecutor(
std::unique_ptr<BrowserUIThreadScheduler> browser_ui_thread_scheduler)
: browser_ui_thread_scheduler_(std::move(browser_ui_thread_scheduler)) {
@@ -436,11 +423,6 @@
return BrowserThread::UI;
}
-const scoped_refptr<base::SequencedTaskRunner>&
-BrowserTaskExecutor::UIThreadExecutor::GetContinuationTaskRunner() {
- return browser_ui_thread_scheduler_->GetTaskRunnerForCurrentTask();
-}
-
BrowserTaskExecutor::IOThreadExecutor::IOThreadExecutor(
std::unique_ptr<BrowserIOThreadDelegate> browser_io_thread_delegate)
: browser_io_thread_delegate_(std::move(browser_io_thread_delegate)) {
@@ -468,10 +450,4 @@
return BrowserThread::IO;
}
-const scoped_refptr<base::SequencedTaskRunner>&
-BrowserTaskExecutor::IOThreadExecutor::GetContinuationTaskRunner() {
- DCHECK(browser_io_thread_delegate_);
- return browser_io_thread_delegate_->GetTaskRunnerForCurrentTask();
-}
-
} // namespace content
diff --git a/content/browser/scheduler/browser_task_executor.h b/content/browser/scheduler/browser_task_executor.h
index af97160..65ec34c2 100644
--- a/content/browser/scheduler/browser_task_executor.h
+++ b/content/browser/scheduler/browser_task_executor.h
@@ -173,10 +173,6 @@
BrowserTaskQueues::Validator* validator);
#endif // DCHECK_IS_ON()
- // base::TaskExecutor implementation.
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
-
private:
friend class BrowserIOThreadDelegate;
friend class BrowserTaskExecutorTest;
@@ -190,10 +186,6 @@
~UIThreadExecutor() override;
- // base::TaskExecutor implementation.
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
-
scoped_refptr<BrowserUIThreadScheduler::Handle> GetUIThreadHandle();
void SetIOThreadHandle(
@@ -217,10 +209,6 @@
~IOThreadExecutor() override;
- // base::TaskExecutor implementation.
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
-
scoped_refptr<BrowserUIThreadScheduler::Handle> GetIOThreadHandle();
void SetUIThreadHandle(
diff --git a/content/browser/scheduler/browser_task_executor_unittest.cc b/content/browser/scheduler/browser_task_executor_unittest.cc
index 5dbac91..9ef50ad 100644
--- a/content/browser/scheduler/browser_task_executor_unittest.cc
+++ b/content/browser/scheduler/browser_task_executor_unittest.cc
@@ -15,7 +15,6 @@
#include "base/task/task_traits.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/test/bind_test_util.h"
-#include "base/test/gtest_util.h"
#include "base/test/mock_callback.h"
#include "base/test/task_environment.h"
#include "base/threading/thread_task_runner_handle.h"
@@ -133,14 +132,6 @@
NOTREACHED();
return BrowserThread::UI;
}
-
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override {
- return dummy_;
- }
-
- private:
- scoped_refptr<base::SequencedTaskRunner> dummy_;
};
template <BrowserThread::ID ID>
@@ -319,35 +310,4 @@
{base::CurrentThread(), BrowserTaskType::kNavigation}));
}
-TEST_F(BrowserTaskExecutorTest, GetContinuationTaskRunner) {
- // Ensure task queue priorities are set.
- BrowserTaskExecutor::PostFeatureListSetup();
- std::vector<int> order;
- base::RunLoop run_loop;
-
- auto task1 = base::BindLambdaForTesting([&]() {
- order.push_back(1);
- run_loop.Quit();
- });
- auto task2 = base::BindLambdaForTesting([&]() { order.push_back(2); });
- auto task3 = base::BindLambdaForTesting([&]() { order.push_back(3); });
-
- base::PostTask(FROM_HERE, {BrowserThread::UI}, task1);
-
- // Post a bootstrap task whose continuation tasks should run before |task1|.
- base::PostTask(
- FROM_HERE, {BrowserThread::UI, BrowserTaskType::kBootstrap},
- base::BindLambdaForTesting([&]() {
- base::GetContinuationTaskRunner()->PostTask(FROM_HERE, task2);
- base::GetContinuationTaskRunner()->PostTask(FROM_HERE, task3);
- }));
-
- run_loop.Run();
- EXPECT_THAT(order, ElementsAre(2, 3, 1));
-}
-
-TEST_F(BrowserTaskExecutorTest, GetContinuationTaskRunnerWithNoTaskExecuting) {
- EXPECT_DCHECK_DEATH(base::GetContinuationTaskRunner());
-}
-
} // namespace content
diff --git a/content/browser/scheduler/browser_ui_thread_scheduler.cc b/content/browser/scheduler/browser_ui_thread_scheduler.cc
index 81d6a51..0925f8f 100644
--- a/content/browser/scheduler/browser_ui_thread_scheduler.cc
+++ b/content/browser/scheduler/browser_ui_thread_scheduler.cc
@@ -63,14 +63,7 @@
void BrowserUIThreadScheduler::CommonSequenceManagerSetup(
base::sequence_manager::SequenceManager* sequence_manager) {
- sequence_manager_ = sequence_manager;
- sequence_manager_->EnableCrashKeys("ui_scheduler_async_stack");
-}
-
-const scoped_refptr<base::SequencedTaskRunner>&
-BrowserUIThreadScheduler::GetTaskRunnerForCurrentTask() const {
- DCHECK(sequence_manager_);
- return sequence_manager_->GetTaskRunnerForCurrentTask();
+ sequence_manager->EnableCrashKeys("ui_scheduler_async_stack");
}
} // namespace content
diff --git a/content/browser/scheduler/browser_ui_thread_scheduler.h b/content/browser/scheduler/browser_ui_thread_scheduler.h
index 88a3e14e..45a7d31 100644
--- a/content/browser/scheduler/browser_ui_thread_scheduler.h
+++ b/content/browser/scheduler/browser_ui_thread_scheduler.h
@@ -40,10 +40,6 @@
scoped_refptr<Handle> GetHandle() const { return handle_; }
- // Must be called on the UI thread.
- const scoped_refptr<base::SequencedTaskRunner>& GetTaskRunnerForCurrentTask()
- const;
-
private:
friend class BrowserTaskExecutor;
@@ -59,7 +55,6 @@
std::unique_ptr<base::sequence_manager::SequenceManager>
owned_sequence_manager_;
- base::sequence_manager::SequenceManager* sequence_manager_ = nullptr;
BrowserTaskQueues task_queues_;
scoped_refptr<Handle> handle_;
diff --git a/content/public/test/browser_task_environment_unittest.cc b/content/public/test/browser_task_environment_unittest.cc
index 854221d..cca1c2c 100644
--- a/content/public/test/browser_task_environment_unittest.cc
+++ b/content/public/test/browser_task_environment_unittest.cc
@@ -11,15 +11,12 @@
#include "base/synchronization/waitable_event.h"
#include "base/task/post_task.h"
#include "base/test/bind_test_util.h"
-#include "base/test/gtest_util.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::test::TaskEnvironment;
-using ::testing::IsNull;
-using ::testing::NotNull;
namespace content {
@@ -226,37 +223,4 @@
run_loop.Run();
}
-TEST(BrowserTaskEnvironmentTest, GetCurrentTaskWithNoTaskRunning) {
- BrowserTaskEnvironment task_environment;
- EXPECT_DCHECK_DEATH(base::GetContinuationTaskRunner());
-}
-
-TEST(BrowserTaskEnvironmentTest, GetContinuationTaskRunnerUI) {
- BrowserTaskEnvironment task_environment;
- base::RunLoop run_loop;
- auto ui_task_runner = base::CreateSingleThreadTaskRunner({BrowserThread::UI});
-
- ui_task_runner->PostTask(FROM_HERE, base::BindLambdaForTesting([&]() {
- EXPECT_EQ(ui_task_runner,
- base::GetContinuationTaskRunner());
- run_loop.Quit();
- }));
-
- run_loop.Run();
-}
-
-TEST(BrowserTaskEnvironmentTest, GetContinuationTaskRunnerIO) {
- BrowserTaskEnvironment task_environment;
- base::RunLoop run_loop;
- auto io_task_runner = base::CreateSingleThreadTaskRunner({BrowserThread::IO});
-
- io_task_runner->PostTask(FROM_HERE, base::BindLambdaForTesting([&]() {
- EXPECT_EQ(io_task_runner,
- base::GetContinuationTaskRunner());
- run_loop.Quit();
- }));
-
- run_loop.Run();
-}
-
} // namespace content
diff --git a/docs/threading_and_tasks.md b/docs/threading_and_tasks.md
index bb1a725..5a705c2c 100644
--- a/docs/threading_and_tasks.md
+++ b/docs/threading_and_tasks.md
@@ -376,6 +376,28 @@
threads](#prefer-sequences-to-physical-threads) and that this thus should rarely
be necessary.
+### Posting to the Current Thread
+
+*** note
+**IMPORTANT:** To post a task that needs mutual exclusion with the current
+sequence of tasks but doesn’t absolutely need to run on the current physical thread,
+use `base::SequencedTaskRunnerHandle::Get()` instead of
+`base::ThreadTaskRunnerHandle::Get()` (ref. [Posting to the Current
+Sequence](#Posting-to-the-Current-Virtual_Thread)). That will better document the
+requirements of the posted task and will avoid unnecessarily making your API
+physical thread-affine. In a single-thread task, `base::SequencedTaskRunnerHandle::Get()`
+is equivalent to `base::ThreadTaskRunnerHandle::Get()`.
+***
+
+If you must post a task to the current physical thread nonetheless, use
+[`base::ThreadTaskRunnerHandle`](https://cs.chromium.org/chromium/src/base/threading/thread_task_runner_handle.h).
+
+```cpp
+// The task will run on the current thread in the future.
+base::ThreadTaskRunnerHandle::Get()->PostTask(
+ FROM_HERE, base::BindOnce(&Task));
+```
+
## Posting Tasks to a COM Single-Thread Apartment (STA) Thread (Windows)
Tasks that need to run on a COM Single-Thread Apartment (STA) thread must be
diff --git a/ios/web/web_thread_impl.cc b/ios/web/web_thread_impl.cc
index 8e35fb9..f7cbf99a 100644
--- a/ios/web/web_thread_impl.cc
+++ b/ios/web/web_thread_impl.cc
@@ -13,7 +13,6 @@
#include "base/compiler_specific.h"
#include "base/lazy_instance.h"
#include "base/macros.h"
-#include "base/no_destructor.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/task/post_task.h"
@@ -145,13 +144,6 @@
return accepting_tasks;
}
-const scoped_refptr<base::SequencedTaskRunner>& GetNullTaskRunner() {
- static const base::NoDestructor<scoped_refptr<base::SequencedTaskRunner>>
- null_task_runner;
- return *null_task_runner;
-}
-
-// Task executor for UI and IO threads.
class WebThreadTaskExecutor : public base::TaskExecutor {
public:
WebThreadTaskExecutor() {}
@@ -185,22 +177,12 @@
return GetTaskRunnerForThread(GetWebThreadIdentifier(traits));
}
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override {
- NOTREACHED() << "WebThreadTaskExecutor isn't registered via "
- "base::SetTaskExecutorForCurrentThread";
- return GetNullTaskRunner();
- }
-
private:
WebThread::ID GetWebThreadIdentifier(const base::TaskTraits& traits) {
DCHECK_EQ(traits.extension_id(), WebTaskTraitsExtension::kExtensionId);
WebThread::ID id =
traits.GetExtension<WebTaskTraitsExtension>().web_thread();
DCHECK_LT(id, WebThread::ID_COUNT);
- DCHECK(!traits.use_current_thread())
- << "WebThreadTaskExecutor isn't registered via "
- "base::SetTaskExecutorForCurrentThread";
// TODO(crbug.com/872372): Support shutdown behavior on UI/IO threads.
if (traits.shutdown_behavior_set_explicitly()) {
@@ -235,13 +217,6 @@
: identifier_(identifier) {
DCHECK(task_runner);
- if (identifier == WebThread::UI) {
- DCHECK(task_runner->BelongsToCurrentThread());
- // TODO(scheduler-dev): Pass the backing SequenceManager in here to ensure
- // GetContinuationTaskRunner DCHECKS when there's no task running.
- ui_thread_tls_executor_.emplace(nullptr, task_runner);
- }
-
WebThreadGlobals& globals = g_globals.Get();
base::AutoLock lock(globals.lock);
diff --git a/ios/web/web_thread_impl.h b/ios/web/web_thread_impl.h
index 51df75bd..401dc2f6 100644
--- a/ios/web/web_thread_impl.h
+++ b/ios/web/web_thread_impl.h
@@ -7,7 +7,6 @@
#include "base/callback.h"
#include "base/memory/scoped_refptr.h"
-#include "base/task/simple_task_executor.h"
#include "base/threading/thread.h"
#include "ios/web/public/thread/web_thread.h"
@@ -66,10 +65,6 @@
// The identifier of this thread. Only one thread can exist with a given
// identifier at a given time.
ID identifier_;
-
- // Here to support base::CurrentThread and base::GetContinuationTaskRunner on
- // the UI thread.
- base::Optional<base::SimpleTaskExecutor> ui_thread_tls_executor_;
};
} // namespace web
diff --git a/ios/web/web_thread_unittest.cc b/ios/web/web_thread_unittest.cc
index 98b4ca8..13011d811 100644
--- a/ios/web/web_thread_unittest.cc
+++ b/ios/web/web_thread_unittest.cc
@@ -6,16 +6,12 @@
#include "base/bind.h"
#include "base/task/post_task.h"
-#include "base/test/bind_test_util.h"
#include "ios/web/public/test/web_task_environment.h"
#include "ios/web/public/thread/web_task_traits.h"
#include "ios/web/web_thread_impl.h"
-#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
-using testing::NotNull;
-
namespace web {
class WebThreadTest : public PlatformTest {
@@ -68,37 +64,4 @@
run_loop.Run();
}
-TEST_F(WebThreadTest, CurrentThread) {
- base::RunLoop run_loop;
-
- base::PostTask(
- FROM_HERE, {base::CurrentThread()}, base::BindLambdaForTesting([&]() {
- PostTask(FROM_HERE, {base::CurrentThread()}, run_loop.QuitClosure());
- }));
-
- run_loop.Run();
-}
-
-TEST_F(WebThreadTest, GetContinuationTaskRunner) {
- base::RunLoop run_loop;
- auto task_runner =
- base::CreateSingleThreadTaskRunner({base::CurrentThread()});
-
- task_runner->PostTask(FROM_HERE, base::BindLambdaForTesting([&]() {
- EXPECT_EQ(task_runner,
- base::GetContinuationTaskRunner());
- run_loop.Quit();
- }));
-
- run_loop.Run();
-}
-
-TEST_F(WebThreadTest, GetContinuationTaskRunnerWithNoTaskRunning) {
- // TODO(scheduler-dev): GetContinuationTaskRunner should DCHECK if there's no
- // task running.
- EXPECT_EQ(base::CreateSequencedTaskRunner({base::CurrentThread()}),
- base::GetContinuationTaskRunner());
- EXPECT_THAT(base::GetContinuationTaskRunner().get(), NotNull());
-}
-
} // namespace web
diff --git a/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc b/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc
index ef55b44..c751d9c 100644
--- a/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc
+++ b/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.cc
@@ -41,7 +41,7 @@
DCHECK(sequence_manager_);
sequence_manager_->SetDefaultTaskRunner(default_task_runner_);
- blink_task_executor_.emplace(default_task_runner_, sequence_manager_);
+ simple_task_executor_.emplace(default_task_runner_);
}
SchedulerHelper::~SchedulerHelper() {
@@ -182,18 +182,5 @@
return false;
}
-SchedulerHelper::BlinkTaskExecutor::BlinkTaskExecutor(
- scoped_refptr<base::SingleThreadTaskRunner> default_task_queue,
- base::sequence_manager::SequenceManager* sequence_manager)
- : base::SimpleTaskExecutor(sequence_manager, std::move(default_task_queue)),
- sequence_manager_(sequence_manager) {}
-
-SchedulerHelper::BlinkTaskExecutor::~BlinkTaskExecutor() = default;
-
-const scoped_refptr<base::SequencedTaskRunner>&
-SchedulerHelper::BlinkTaskExecutor::GetContinuationTaskRunner() {
- return sequence_manager_->GetTaskRunnerForCurrentTask();
-}
-
} // namespace scheduler
} // namespace blink
diff --git a/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h b/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h
index 52b84746..3f2267e 100644
--- a/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h
+++ b/third_party/blink/renderer/platform/scheduler/common/scheduler_helper.h
@@ -130,29 +130,12 @@
private:
friend class SchedulerHelperTest;
- // Like SimpleTaskExecutor except it knows how to get the current task runner
- // from the SequenceManager to implement GetContinuationTaskRunner.
- class BlinkTaskExecutor : public base::SimpleTaskExecutor {
- public:
- BlinkTaskExecutor(
- scoped_refptr<base::SingleThreadTaskRunner> default_task_queue,
- base::sequence_manager::SequenceManager* sequence_manager);
-
- ~BlinkTaskExecutor() override;
-
- // base::TaskExecutor implementation.
- const scoped_refptr<base::SequencedTaskRunner>& GetContinuationTaskRunner()
- override;
-
- private:
- base::sequence_manager::SequenceManager* sequence_manager_; // NOT OWNED
- };
scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
Observer* observer_; // NOT OWNED
UkmTaskSampler ukm_task_sampler_;
- base::Optional<BlinkTaskExecutor> blink_task_executor_;
+ base::Optional<base::SimpleTaskExecutor> simple_task_executor_;
DISALLOW_COPY_AND_ASSIGN(SchedulerHelper);
};
diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
index c44eecf..1592325c 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
@@ -18,7 +18,6 @@
#include "base/task/sequence_manager/test/sequence_manager_for_test.h"
#include "base/task/task_executor.h"
#include "base/test/bind_test_util.h"
-#include "base/test/gtest_util.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/simple_test_tick_clock.h"
@@ -47,7 +46,6 @@
// To avoid symbol collisions in jumbo builds.
namespace main_thread_scheduler_impl_unittest {
-using testing::IsNull;
using testing::Mock;
using testing::NotNull;
using InputEventState = WebThreadScheduler::InputEventState;
@@ -2090,25 +2088,6 @@
{base::CurrentThread(), base::TaskPriority::BEST_EFFORT}));
}
-TEST_F(MainThreadSchedulerImplTest, GetContinuationTaskRunner) {
- scoped_refptr<MainThreadTaskQueue> timer_tq = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::kFrameThrottleable, nullptr);
- auto task_runner = timer_tq->CreateTaskRunner(TaskType::kJavascriptTimer);
-
- base::RunLoop run_loop;
- task_runner->PostTask(FROM_HERE, base::BindLambdaForTesting([&]() {
- EXPECT_EQ(task_runner,
- base::GetContinuationTaskRunner());
- run_loop.Quit();
- }));
- run_loop.Run();
-}
-
-TEST_F(MainThreadSchedulerImplTest,
- GetContinuationTaskRunnerWithNoTaskRunning) {
- EXPECT_DCHECK_DEATH(base::GetContinuationTaskRunner());
-}
-
TEST_F(MainThreadSchedulerImplTest, TestBeginMainFrameNotExpectedUntil) {
base::TimeDelta ten_millis(base::TimeDelta::FromMilliseconds(10));
base::TimeTicks expected_deadline = Now() + ten_millis;
