Skip to content

GitLab

T
tangled
Commit 17f533a1 authored by Alexander Timin's avatar Alexander Timin Committed by Commit Bot
Browse files
Options

Quick Cleanup for TaskQueueManager 

BUG=783309

Change-Id: Ibb2fe849a2ef7d1bec48fbacea14d12cea783bd7
Reviewed-on: https://chromium-review.googlesource.com/763875
Commit-Queue: Alexander Timin <altimin@chromium.org>
Reviewed-by: default avatarAlexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#525370}
parent baf650e8
Hide whitespace changes
Inline Side-by-side
Showing with 96 additions and 103 deletions
third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
View file @ 17f533a1
...@@ -21,15 +21,26 @@ ...@@ -21,15 +21,26 @@
#include "platform/scheduler/base/work_queue.h" #include "platform/scheduler/base/work_queue.h"
#include "platform/scheduler/base/work_queue_sets.h" #include "platform/scheduler/base/work_queue_sets.h"
static const double kLongTaskTraceEventThreshold = 0.05;
namespace blink { namespace blink {
namespace scheduler { namespace scheduler {
namespace { namespace {
const double kLongTaskTraceEventThreshold = 0.05;
double MonotonicTimeInSeconds(base::TimeTicks time_ticks) { double MonotonicTimeInSeconds(base::TimeTicks time_ticks) {
return (time_ticks - base::TimeTicks()).InSecondsF(); return (time_ticks - base::TimeTicks()).InSecondsF();
} }
void SweepCanceledDelayedTasksInQueue(
internal::TaskQueueImpl* queue,
std::map<TimeDomain*, base::TimeTicks>* time_domain_now) {
TimeDomain* time_domain = queue->GetTimeDomain();
if (time_domain_now->find(time_domain) == time_domain_now->end())
time_domain_now->insert(std::make_pair(time_domain, time_domain->Now()));
queue->SweepCanceledDelayedTasks(time_domain_now->at(time_domain));
}
} // namespace } // namespace
TaskQueueManager::TaskQueueManager( TaskQueueManager::TaskQueueManager(
...@@ -37,11 +48,6 @@ TaskQueueManager::TaskQueueManager( ...@@ -37,11 +48,6 @@ TaskQueueManager::TaskQueueManager(
: real_time_domain_(new RealTimeDomain()), : real_time_domain_(new RealTimeDomain()),
graceful_shutdown_helper_(new internal::GracefulQueueShutdownHelper()), graceful_shutdown_helper_(new internal::GracefulQueueShutdownHelper()),
controller_(std::move(controller)), controller_(std::move(controller)),
task_was_run_on_quiescence_monitored_queue_(false),
work_batch_size_(1),
task_count_(0),
currently_executing_task_queue_(nullptr),
observer_(nullptr),
weak_factory_(this) { weak_factory_(this) {
// TODO(altimin): Create a sequence checker here. // TODO(altimin): Create a sequence checker here.
DCHECK(controller_->RunsTasksInCurrentSequence()); DCHECK(controller_->RunsTasksInCurrentSequence());
...@@ -88,11 +94,6 @@ std::unique_ptr<TaskQueueManager> TaskQueueManager::TakeOverCurrentThread() { ...@@ -88,11 +94,6 @@ std::unique_ptr<TaskQueueManager> TaskQueueManager::TakeOverCurrentThread() {
base::DefaultTickClock::GetInstance()))); base::DefaultTickClock::GetInstance())));
} }
TaskQueueManager::AnyThread::AnyThread()
: do_work_running_count(0),
immediate_do_work_posted_count(0),
is_nested(false) {}
void TaskQueueManager::RegisterTimeDomain(TimeDomain* time_domain) { void TaskQueueManager::RegisterTimeDomain(TimeDomain* time_domain) {
time_domains_.insert(time_domain); time_domains_.insert(time_domain);
time_domain->OnRegisterWithTaskQueueManager(this); time_domain->OnRegisterWithTaskQueueManager(this);
...@@ -104,7 +105,7 @@ void TaskQueueManager::UnregisterTimeDomain(TimeDomain* time_domain) { ...@@ -104,7 +105,7 @@ void TaskQueueManager::UnregisterTimeDomain(TimeDomain* time_domain) {
std::unique_ptr<internal::TaskQueueImpl> TaskQueueManager::CreateTaskQueueImpl( std::unique_ptr<internal::TaskQueueImpl> TaskQueueManager::CreateTaskQueueImpl(
const TaskQueue::Spec& spec) { const TaskQueue::Spec& spec) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
TimeDomain* time_domain = TimeDomain* time_domain =
spec.time_domain ? spec.time_domain : real_time_domain_.get(); spec.time_domain ? spec.time_domain : real_time_domain_.get();
DCHECK(time_domains_.find(time_domain) != time_domains_.end()); DCHECK(time_domains_.find(time_domain) != time_domains_.end());
...@@ -116,7 +117,7 @@ std::unique_ptr<internal::TaskQueueImpl> TaskQueueManager::CreateTaskQueueImpl( ...@@ -116,7 +117,7 @@ std::unique_ptr<internal::TaskQueueImpl> TaskQueueManager::CreateTaskQueueImpl(
} }
void TaskQueueManager::SetObserver(Observer* observer) { void TaskQueueManager::SetObserver(Observer* observer) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
observer_ = observer; observer_ = observer;
} }
...@@ -124,7 +125,7 @@ void TaskQueueManager::UnregisterTaskQueueImpl( ...@@ -124,7 +125,7 @@ void TaskQueueManager::UnregisterTaskQueueImpl(
std::unique_ptr<internal::TaskQueueImpl> task_queue) { std::unique_ptr<internal::TaskQueueImpl> task_queue) {
TRACE_EVENT1("renderer.scheduler", "TaskQueueManager::UnregisterTaskQueue", TRACE_EVENT1("renderer.scheduler", "TaskQueueManager::UnregisterTaskQueue",
"queue_name", task_queue->GetName()); "queue_name", task_queue->GetName());
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
selector_.RemoveQueue(task_queue.get()); selector_.RemoveQueue(task_queue.get());
...@@ -222,7 +223,7 @@ void TaskQueueManager::MaybeScheduleDelayedWork( ...@@ -222,7 +223,7 @@ void TaskQueueManager::MaybeScheduleDelayedWork(
TimeDomain* requesting_time_domain, TimeDomain* requesting_time_domain,
base::TimeTicks now, base::TimeTicks now,
base::TimeTicks run_time) { base::TimeTicks run_time) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
// Make sure we don't cancel another TimeDomain's wake-up. // Make sure we don't cancel another TimeDomain's wake-up.
DCHECK(!next_delayed_do_work_ || DCHECK(!next_delayed_do_work_ ||
next_delayed_do_work_.time_domain() == requesting_time_domain); next_delayed_do_work_.time_domain() == requesting_time_domain);
...@@ -254,7 +255,7 @@ void TaskQueueManager::MaybeScheduleDelayedWork( ...@@ -254,7 +255,7 @@ void TaskQueueManager::MaybeScheduleDelayedWork(
void TaskQueueManager::CancelDelayedWork(TimeDomain* requesting_time_domain, void TaskQueueManager::CancelDelayedWork(TimeDomain* requesting_time_domain,
base::TimeTicks run_time) { base::TimeTicks run_time) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
if (next_delayed_do_work_.run_time() != run_time) if (next_delayed_do_work_.run_time() != run_time)
return; return;
...@@ -264,7 +265,7 @@ void TaskQueueManager::CancelDelayedWork(TimeDomain* requesting_time_domain, ...@@ -264,7 +265,7 @@ void TaskQueueManager::CancelDelayedWork(TimeDomain* requesting_time_domain,
} }
void TaskQueueManager::DoWork(WorkType work_type) { void TaskQueueManager::DoWork(WorkType work_type) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
TRACE_EVENT1("renderer.scheduler", "TaskQueueManager::DoWork", "delayed", TRACE_EVENT1("renderer.scheduler", "TaskQueueManager::DoWork", "delayed",
work_type == WorkType::kDelayed); work_type == WorkType::kDelayed);
...@@ -369,7 +370,7 @@ void TaskQueueManager::PostDoWorkContinuationLocked( ...@@ -369,7 +370,7 @@ void TaskQueueManager::PostDoWorkContinuationLocked(
base::Optional<NextTaskDelay> next_delay, base::Optional<NextTaskDelay> next_delay,
LazyNow* lazy_now, LazyNow* lazy_now,
MoveableAutoLock lock) { MoveableAutoLock lock) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
{ {
MoveableAutoLock auto_lock(std::move(lock)); MoveableAutoLock auto_lock(std::move(lock));
...@@ -388,7 +389,7 @@ void TaskQueueManager::PostDoWorkContinuationLocked( ...@@ -388,7 +389,7 @@ void TaskQueueManager::PostDoWorkContinuationLocked(
if (any_thread().immediate_do_work_posted_count > 0) if (any_thread().immediate_do_work_posted_count > 0)
return; return;
if (next_delay->Delay() <= base::TimeDelta()) { if (next_delay->delay() <= base::TimeDelta()) {
// If a delayed DoWork is pending then we don't need to post a // If a delayed DoWork is pending then we don't need to post a
// continuation because it should run immediately. // continuation because it should run immediately.
if (next_delayed_do_work_ && if (next_delayed_do_work_ &&
...@@ -401,23 +402,23 @@ void TaskQueueManager::PostDoWorkContinuationLocked( ...@@ -401,23 +402,23 @@ void TaskQueueManager::PostDoWorkContinuationLocked(
} }
// We avoid holding |any_thread_lock_| while posting the task. // We avoid holding |any_thread_lock_| while posting the task.
if (next_delay->Delay() <= base::TimeDelta()) { if (next_delay->delay() <= base::TimeDelta()) {
controller_->ScheduleWork(); controller_->ScheduleWork();
} else { } else {
base::TimeTicks run_time = lazy_now->Now() + next_delay->Delay(); base::TimeTicks run_time = lazy_now->Now() + next_delay->delay();
if (next_delayed_do_work_.run_time() == run_time) if (next_delayed_do_work_.run_time() == run_time)
return; return;
next_delayed_do_work_ = next_delayed_do_work_ =
NextDelayedDoWork(run_time, next_delay->time_domain()); NextDelayedDoWork(run_time, next_delay->time_domain());
controller_->ScheduleDelayedWork(next_delay->Delay()); controller_->ScheduleDelayedWork(next_delay->delay());
} }
} }
base::Optional<TaskQueueManager::NextTaskDelay> base::Optional<TaskQueueManager::NextTaskDelay>
TaskQueueManager::ComputeDelayTillNextTaskLocked(LazyNow* lazy_now) { TaskQueueManager::ComputeDelayTillNextTaskLocked(LazyNow* lazy_now) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
// Unfortunately because |any_thread_lock_| is held it's not safe to call // Unfortunately because |any_thread_lock_| is held it's not safe to call
// ReloadEmptyWorkQueues here (possible lock order inversion), however this // ReloadEmptyWorkQueues here (possible lock order inversion), however this
...@@ -471,7 +472,7 @@ TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue( ...@@ -471,7 +472,7 @@ TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue(
bool is_nested, bool is_nested,
LazyNow time_before_task, LazyNow time_before_task,
base::TimeTicks* time_after_task) { base::TimeTicks* time_after_task) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
base::WeakPtr<TaskQueueManager> protect = GetWeakPtr(); base::WeakPtr<TaskQueueManager> protect = GetWeakPtr();
internal::TaskQueueImpl::Task pending_task = internal::TaskQueueImpl::Task pending_task =
work_queue->TakeTaskFromWorkQueue(); work_queue->TakeTaskFromWorkQueue();
...@@ -625,32 +626,32 @@ void TaskQueueManager::NotifyDidProcessTaskObservers( ...@@ -625,32 +626,32 @@ void TaskQueueManager::NotifyDidProcessTaskObservers(
} }
void TaskQueueManager::SetWorkBatchSize(int work_batch_size) { void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
DCHECK_GE(work_batch_size, 1); DCHECK_GE(work_batch_size, 1);
work_batch_size_ = work_batch_size; work_batch_size_ = work_batch_size;
} }
void TaskQueueManager::AddTaskObserver( void TaskQueueManager::AddTaskObserver(
base::MessageLoop::TaskObserver* task_observer) { base::MessageLoop::TaskObserver* task_observer) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
task_observers_.AddObserver(task_observer); task_observers_.AddObserver(task_observer);
} }
void TaskQueueManager::RemoveTaskObserver( void TaskQueueManager::RemoveTaskObserver(
base::MessageLoop::TaskObserver* task_observer) { base::MessageLoop::TaskObserver* task_observer) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
task_observers_.RemoveObserver(task_observer); task_observers_.RemoveObserver(task_observer);
} }
void TaskQueueManager::AddTaskTimeObserver( void TaskQueueManager::AddTaskTimeObserver(
TaskTimeObserver* task_time_observer) { TaskTimeObserver* task_time_observer) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
task_time_observers_.AddObserver(task_time_observer); task_time_observers_.AddObserver(task_time_observer);
} }
void TaskQueueManager::RemoveTaskTimeObserver( void TaskQueueManager::RemoveTaskTimeObserver(
TaskTimeObserver* task_time_observer) { TaskTimeObserver* task_time_observer) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
task_time_observers_.RemoveObserver(task_time_observer); task_time_observers_.RemoveObserver(task_time_observer);
} }
...@@ -679,7 +680,7 @@ std::unique_ptr<base::trace_event::ConvertableToTraceFormat> ...@@ -679,7 +680,7 @@ std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
TaskQueueManager::AsValueWithSelectorResult( TaskQueueManager::AsValueWithSelectorResult(
bool should_run, bool should_run,
internal::WorkQueue* selected_work_queue) const { internal::WorkQueue* selected_work_queue) const {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
std::unique_ptr<base::trace_event::TracedValue> state( std::unique_ptr<base::trace_event::TracedValue> state(
new base::trace_event::TracedValue()); new base::trace_event::TracedValue());
base::TimeTicks now = real_time_domain()->CreateLazyNow().Now(); base::TimeTicks now = real_time_domain()->CreateLazyNow().Now();
...@@ -726,7 +727,7 @@ TaskQueueManager::AsValueWithSelectorResult( ...@@ -726,7 +727,7 @@ TaskQueueManager::AsValueWithSelectorResult(
} }
void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) { void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
DCHECK(queue->IsQueueEnabled()); DCHECK(queue->IsQueueEnabled());
// Only schedule DoWork if there's something to do. // Only schedule DoWork if there's something to do.
if (queue->HasTaskToRunImmediately() && !queue->BlockedByFence()) if (queue->HasTaskToRunImmediately() && !queue->BlockedByFence())
...@@ -735,7 +736,7 @@ void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) { ...@@ -735,7 +736,7 @@ void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
void TaskQueueManager::OnTriedToSelectBlockedWorkQueue( void TaskQueueManager::OnTriedToSelectBlockedWorkQueue(
internal::WorkQueue* work_queue) { internal::WorkQueue* work_queue) {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
DCHECK(!work_queue->Empty()); DCHECK(!work_queue->Empty());
if (observer_) if (observer_)
observer_->OnTriedToExecuteBlockedTask(); observer_->OnTriedToExecuteBlockedTask();
...@@ -745,19 +746,6 @@ bool TaskQueueManager::HasImmediateWorkForTesting() const { ...@@ -745,19 +746,6 @@ bool TaskQueueManager::HasImmediateWorkForTesting() const {
return !selector_.EnabledWorkQueuesEmpty(); return !selector_.EnabledWorkQueuesEmpty();
} }
namespace {
void SweepCanceledDelayedTasksInQueue(
internal::TaskQueueImpl* queue,
std::map<TimeDomain*, base::TimeTicks>* time_domain_now) {
TimeDomain* time_domain = queue->GetTimeDomain();
if (time_domain_now->find(time_domain) == time_domain_now->end())
time_domain_now->insert(std::make_pair(time_domain, time_domain->Now()));
queue->SweepCanceledDelayedTasks(time_domain_now->at(time_domain));
}
} // namespace
void TaskQueueManager::SweepCanceledDelayedTasks() { void TaskQueueManager::SweepCanceledDelayedTasks() {
std::map<TimeDomain*, base::TimeTicks> time_domain_now; std::map<TimeDomain*, base::TimeTicks> time_domain_now;
for (const auto& queue : active_queues_) for (const auto& queue : active_queues_)
......
third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h
View file @ 17f533a1
...@@ -33,14 +33,16 @@ class ConvertableToTraceFormat; ...@@ -33,14 +33,16 @@ class ConvertableToTraceFormat;
namespace blink { namespace blink {
namespace scheduler { namespace scheduler {
namespace task_queue_manager_unittest {
class TaskQueueManagerTest;
}
namespace internal { namespace internal {
class TaskQueueImpl; class TaskQueueImpl;
class ThreadController; class ThreadController;
} // namespace internal } // namespace internal
namespace task_queue_manager_unittest {
class TaskQueueManagerTest;
} // namespace task_queue_manager_unittest
class LazyNow; class LazyNow;
class RealTimeDomain; class RealTimeDomain;
class TaskQueue; class TaskQueue;
...@@ -53,7 +55,7 @@ class TimeDomain; ...@@ -53,7 +55,7 @@ class TimeDomain;
// //
// 1. Incoming task queue. Tasks that are posted get immediately appended here. // 1. Incoming task queue. Tasks that are posted get immediately appended here.
// When a task is appended into an empty incoming queue, the task manager // When a task is appended into an empty incoming queue, the task manager
// work function (DoWork) is scheduled to run on the main task runner. // work function (DoWork()) is scheduled to run on the main task runner.
// //
// 2. Work queue. If a work queue is empty when DoWork() is entered, tasks from // 2. Work queue. If a work queue is empty when DoWork() is entered, tasks from
// the incoming task queue (if any) are moved here. The work queues are // the incoming task queue (if any) are moved here. The work queues are
...@@ -66,6 +68,18 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -66,6 +68,18 @@ class PLATFORM_EXPORT TaskQueueManager
public internal::TaskQueueSelector::Observer, public internal::TaskQueueSelector::Observer,
public base::RunLoop::NestingObserver { public base::RunLoop::NestingObserver {
public: public:
// Observer class that is called back on the main thread.
class PLATFORM_EXPORT Observer {
public:
virtual ~Observer() {}
virtual void OnTriedToExecuteBlockedTask() = 0;
virtual void OnBeginNestedRunLoop() = 0;
virtual void OnExitNestedRunLoop() = 0;
};
~TaskQueueManager() override; ~TaskQueueManager() override;
// Assume direct control over current thread and create a TaskQueueManager. // Assume direct control over current thread and create a TaskQueueManager.
...@@ -86,7 +100,7 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -86,7 +100,7 @@ class PLATFORM_EXPORT TaskQueueManager
// Requests that a task to process work is posted on the main task runner. // Requests that a task to process work is posted on the main task runner.
// These tasks are de-duplicated in two buckets: main-thread and all other // These tasks are de-duplicated in two buckets: main-thread and all other
// threads. This distinction is done to reduce the overehead from locks, we // threads. This distinction is done to reduce the overhead from locks, we
// assume the main-thread path will be hot. // assume the main-thread path will be hot.
void MaybeScheduleImmediateWork(const base::Location& from_here); void MaybeScheduleImmediateWork(const base::Location& from_here);
...@@ -131,20 +145,9 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -131,20 +145,9 @@ class PLATFORM_EXPORT TaskQueueManager
return task_queue; return task_queue;
} }
class PLATFORM_EXPORT Observer {
public:
virtual ~Observer() {}
virtual void OnTriedToExecuteBlockedTask() = 0;
virtual void OnBeginNestedRunLoop() = 0;
virtual void OnExitNestedRunLoop() = 0;
};
// Called once to set the Observer. This function is called on the main // Called once to set the Observer. This function is called on the main
// thread. If |observer| is null, then no callbacks will occur. // thread. If |observer| is null, then no callbacks will occur.
// Note |observer| is expected to outlive the SchedulerHelper. // Note: |observer| is expected to outlive the SchedulerHelper.
void SetObserver(Observer* observer); void SetObserver(Observer* observer);
// Time domains must be registered for the task queues to get updated. // Time domains must be registered for the task queues to get updated.
...@@ -158,7 +161,7 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -158,7 +161,7 @@ class PLATFORM_EXPORT TaskQueueManager
// Returns the currently executing TaskQueue if any. Must be called on the // Returns the currently executing TaskQueue if any. Must be called on the
// thread this class was created on. // thread this class was created on.
internal::TaskQueueImpl* currently_executing_task_queue() const { internal::TaskQueueImpl* currently_executing_task_queue() const {
DCHECK(main_thread_checker_.CalledOnValidThread()); DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
return currently_executing_task_queue_; return currently_executing_task_queue_;
} }
...@@ -214,7 +217,7 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -214,7 +217,7 @@ class PLATFORM_EXPORT TaskQueueManager
DCHECK(time_domain); DCHECK(time_domain);
} }
base::TimeDelta Delay() const { return delay_; } base::TimeDelta delay() const { return delay_; }
TimeDomain* time_domain() const { return time_domain_; } TimeDomain* time_domain() const { return time_domain_; }
bool operator>(const NextTaskDelay& other) const { bool operator>(const NextTaskDelay& other) const {
...@@ -266,12 +269,35 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -266,12 +269,35 @@ class PLATFORM_EXPORT TaskQueueManager
TimeDomain* time_domain_; TimeDomain* time_domain_;
}; };
// TaskQueueSelector::Observer implementation: enum class ProcessTaskResult {
kDeferred,
kExecuted,
kTaskQueueManagerDeleted,
};
using IncomingImmediateWorkMap =
std::unordered_map<internal::TaskQueueImpl*, internal::EnqueueOrder>;
struct AnyThread {
AnyThread() = default;
// Task queues with newly available work on the incoming queue.
IncomingImmediateWorkMap has_incoming_immediate_work;
int do_work_running_count = 0;
int immediate_do_work_posted_count = 0;
// Whether or not the message loop is currently nested.
bool is_nested = false;
};
// TODO(alexclarke): Add a MainThreadOnly struct too.
// TaskQueueSelector::Observer:
void OnTaskQueueEnabled(internal::TaskQueueImpl* queue) override; void OnTaskQueueEnabled(internal::TaskQueueImpl* queue) override;
void OnTriedToSelectBlockedWorkQueue( void OnTriedToSelectBlockedWorkQueue(
internal::WorkQueue* work_queue) override; internal::WorkQueue* work_queue) override;
// base::RunLoop::NestingObserver implementation: // base::RunLoop::NestingObserver:
void OnBeginNestedRunLoop() override; void OnBeginNestedRunLoop() override;
// Called by the task queue to register a new pending task. // Called by the task queue to register a new pending task.
...@@ -280,7 +306,7 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -280,7 +306,7 @@ class PLATFORM_EXPORT TaskQueueManager
// Use the selector to choose a pending task and run it. // Use the selector to choose a pending task and run it.
void DoWork(WorkType work_type); void DoWork(WorkType work_type);
// Post a DoWork continuation if |next_delay| is not empty. // Post a DoWork() continuation if |next_delay| is not empty.
void PostDoWorkContinuationLocked(base::Optional<NextTaskDelay> next_delay, void PostDoWorkContinuationLocked(base::Optional<NextTaskDelay> next_delay,
LazyNow* lazy_now, LazyNow* lazy_now,
MoveableAutoLock lock); MoveableAutoLock lock);
...@@ -294,15 +320,9 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -294,15 +320,9 @@ class PLATFORM_EXPORT TaskQueueManager
// avoid running any tasks. // avoid running any tasks.
bool SelectWorkQueueToService(internal::WorkQueue** out_work_queue); bool SelectWorkQueueToService(internal::WorkQueue** out_work_queue);
enum class ProcessTaskResult {
kDeferred,
kExecuted,
kTaskQueueManagerDeleted,
};
// Runs a single nestable task from the |queue|. On exit, |out_task| will // Runs a single nestable task from the |queue|. On exit, |out_task| will
// contain the task which was executed. Non-nestable task are reposted on the // contain the task which was executed. Non-nestable task are reposted on the
// run loop. The queue must not be empty. On exit |time_after_task| may get // run loop. The queue must not be empty. On exit |time_after_task| may get
// set (not guaranteed), sampling |real_time_domain()->Now()| immediately // set (not guaranteed), sampling |real_time_domain()->Now()| immediately
// after running the task. // after running the task.
ProcessTaskResult ProcessTaskFromWorkQueue(internal::WorkQueue* work_queue, ProcessTaskResult ProcessTaskFromWorkQueue(internal::WorkQueue* work_queue,
...@@ -345,9 +365,6 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -345,9 +365,6 @@ class PLATFORM_EXPORT TaskQueueManager
internal::EnqueueOrder enqueue_order, internal::EnqueueOrder enqueue_order,
bool queue_is_blocked); bool queue_is_blocked);
using IncomingImmediateWorkMap =
std::unordered_map<internal::TaskQueueImpl*, internal::EnqueueOrder>;
// Calls |ReloadImmediateWorkQueueIfEmpty| on all queues in // Calls |ReloadImmediateWorkQueueIfEmpty| on all queues in
// |queues_to_reload|. // |queues_to_reload|.
void ReloadEmptyWorkQueues( void ReloadEmptyWorkQueues(
...@@ -386,24 +403,11 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -386,24 +403,11 @@ class PLATFORM_EXPORT TaskQueueManager
internal::EnqueueOrderGenerator enqueue_order_generator_; internal::EnqueueOrderGenerator enqueue_order_generator_;
base::debug::TaskAnnotator task_annotator_; base::debug::TaskAnnotator task_annotator_;
base::ThreadChecker main_thread_checker_; THREAD_CHECKER(main_thread_checker_);
std::unique_ptr<internal::ThreadController> controller_; std::unique_ptr<internal::ThreadController> controller_;
internal::TaskQueueSelector selector_; internal::TaskQueueSelector selector_;
bool task_was_run_on_quiescence_monitored_queue_; bool task_was_run_on_quiescence_monitored_queue_ = false;
struct AnyThread {
AnyThread();
// Task queues with newly available work on the incoming queue.
IncomingImmediateWorkMap has_incoming_immediate_work;
int do_work_running_count;
int immediate_do_work_posted_count;
bool is_nested; // Whether or not the message loop is currently nested.
};
// TODO(alexclarke): Add a MainThreadOnly struct too.
mutable base::Lock any_thread_lock_; mutable base::Lock any_thread_lock_;
AnyThread any_thread_; AnyThread any_thread_;
...@@ -419,16 +423,17 @@ class PLATFORM_EXPORT TaskQueueManager ...@@ -419,16 +423,17 @@ class PLATFORM_EXPORT TaskQueueManager
NextDelayedDoWork next_delayed_do_work_; NextDelayedDoWork next_delayed_do_work_;
int work_batch_size_; int work_batch_size_ = 1;
size_t task_count_; size_t task_count_ = 0;
base::ObserverList<base::MessageLoop::TaskObserver> task_observers_; base::ObserverList<base::MessageLoop::TaskObserver> task_observers_;
base::ObserverList<TaskTimeObserver> task_time_observers_; base::ObserverList<TaskTimeObserver> task_time_observers_;
internal::TaskQueueImpl* currently_executing_task_queue_; // NOT OWNED // NOT OWNED
internal::TaskQueueImpl* currently_executing_task_queue_ = nullptr;
Observer* observer_; // NOT OWNED Observer* observer_ = nullptr; // NOT OWNED
base::WeakPtrFactory<TaskQueueManager> weak_factory_; base::WeakPtrFactory<TaskQueueManager> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(TaskQueueManager); DISALLOW_COPY_AND_ASSIGN(TaskQueueManager);
......
third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
View file @ 17f533a1
...@@ -2619,23 +2619,23 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) { ...@@ -2619,23 +2619,23 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask) {
base::TimeDelta::FromSeconds(10)); base::TimeDelta::FromSeconds(10));
EXPECT_EQ(base::TimeDelta::FromSeconds(10), EXPECT_EQ(base::TimeDelta::FromSeconds(10),
ComputeDelayTillNextTask(&lazy_now)->Delay()); ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(15)); base::TimeDelta::FromSeconds(15));
EXPECT_EQ(base::TimeDelta::FromSeconds(10), EXPECT_EQ(base::TimeDelta::FromSeconds(10),
ComputeDelayTillNextTask(&lazy_now)->Delay()); ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask), runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&NopTask),
base::TimeDelta::FromSeconds(5)); base::TimeDelta::FromSeconds(5));
EXPECT_EQ(base::TimeDelta::FromSeconds(5), EXPECT_EQ(base::TimeDelta::FromSeconds(5),
ComputeDelayTillNextTask(&lazy_now)->Delay()); ComputeDelayTillNextTask(&lazy_now)->delay());
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask)); runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->Delay()); EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
} }
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Disabled) { TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Disabled) {
...@@ -2668,7 +2668,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_FenceUnblocking) { ...@@ -2668,7 +2668,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_FenceUnblocking) {
runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow); runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
LazyNow lazy_now(&now_src_); LazyNow lazy_now(&now_src_);
EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->Delay()); EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
} }
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) { TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
...@@ -2680,7 +2680,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) { ...@@ -2680,7 +2680,7 @@ TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_DelayedTaskReady) {
now_src_.Advance(base::TimeDelta::FromSeconds(10)); now_src_.Advance(base::TimeDelta::FromSeconds(10));
LazyNow lazy_now(&now_src_); LazyNow lazy_now(&now_src_);
EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->Delay()); EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->delay());
} }
TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) { TEST_F(TaskQueueManagerTest, PostDoWorkContinuation_NoMoreWork) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment