[scheduler] Blink-style enum names in scheduler
R=haraken@chromium.org
Change-Id: Ia88e4aefd42f295a0768dd9ae68e6b2f822d84ed
Reviewed-on: https://chromium-review.googlesource.com/766794
Commit-Queue: Alexander Timin <altimin@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#516302}diff --git a/third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.cpp
index ce35c71..d5e56ea 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorEmulationAgent.cpp
@@ -142,14 +142,14 @@
protocol::Maybe<int> max_virtual_time_task_starvation_count) {
if (protocol::Emulation::VirtualTimePolicyEnum::Advance == policy) {
web_local_frame_->View()->Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
} else if (protocol::Emulation::VirtualTimePolicyEnum::Pause == policy) {
web_local_frame_->View()->Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
+ WebViewScheduler::VirtualTimePolicy::kPause);
} else if (protocol::Emulation::VirtualTimePolicyEnum::
PauseIfNetworkFetchesPending == policy) {
web_local_frame_->View()->Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::DETERMINISTIC_LOADING);
+ WebViewScheduler::VirtualTimePolicy::kDeterministicLoading);
}
web_local_frame_->View()->Scheduler()->EnableVirtualTime();
if (!virtual_time_observer_registered_) {
@@ -182,7 +182,7 @@
void InspectorEmulationAgent::VirtualTimeBudgetExpired() {
web_local_frame_->View()->Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
+ WebViewScheduler::VirtualTimePolicy::kPause);
GetFrontend()->virtualTimeBudgetExpired();
}
diff --git a/third_party/WebKit/Source/core/layout/ScrollbarsTest.cpp b/third_party/WebKit/Source/core/layout/ScrollbarsTest.cpp
index 3ad2331..f48ef85 100644
--- a/third_party/WebKit/Source/core/layout/ScrollbarsTest.cpp
+++ b/third_party/WebKit/Source/core/layout/ScrollbarsTest.cpp
@@ -106,12 +106,12 @@
void TimeAdvance() {
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
}
void StopVirtualTimeAndExitRunLoop() {
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
+ WebViewScheduler::VirtualTimePolicy::kPause);
testing::ExitRunLoop();
}
diff --git a/third_party/WebKit/Source/core/scheduler/VirtualTimeTest.cpp b/third_party/WebKit/Source/core/scheduler/VirtualTimeTest.cpp
index 7e6f4982..78444618 100644
--- a/third_party/WebKit/Source/core/scheduler/VirtualTimeTest.cpp
+++ b/third_party/WebKit/Source/core/scheduler/VirtualTimeTest.cpp
@@ -53,7 +53,7 @@
void StopVirtualTimeAndExitRunLoop() {
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
+ WebViewScheduler::VirtualTimePolicy::kPause);
testing::ExitRunLoop();
}
@@ -82,7 +82,7 @@
TEST_F(VirtualTimeTest, MAYBE_DOMTimersFireInExpectedOrder) {
WebView().Scheduler()->EnableVirtualTime();
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
ExecuteJavaScript(
"var run_order = [];"
@@ -111,7 +111,7 @@
TEST_F(VirtualTimeTest, MAYBE_SetInterval) {
WebView().Scheduler()->EnableVirtualTime();
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
ExecuteJavaScript(
"var run_order = [];"
@@ -139,7 +139,7 @@
TEST_F(VirtualTimeTest, MAYBE_AllowVirtualTimeToAdvance) {
WebView().Scheduler()->EnableVirtualTime();
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
+ WebViewScheduler::VirtualTimePolicy::kPause);
ExecuteJavaScript(
"var run_order = [];"
@@ -154,7 +154,7 @@
EXPECT_EQ("", ExecuteJavaScript("run_order.join(', ')"));
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
RunTasksForPeriod(1000);
EXPECT_EQ("c, b, a", ExecuteJavaScript("run_order.join(', ')"));
@@ -172,7 +172,7 @@
MAYBE_VirtualTimeNotAllowedToAdvanceWhileResourcesLoading) {
WebView().Scheduler()->EnableVirtualTime();
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::DETERMINISTIC_LOADING);
+ WebViewScheduler::VirtualTimePolicy::kDeterministicLoading);
EXPECT_TRUE(WebView().Scheduler()->VirtualTimeAllowedToAdvance());
@@ -216,7 +216,7 @@
TEST_F(VirtualTimeTest, MAYBE_DOMTimersSuspended) {
WebView().Scheduler()->EnableVirtualTime();
WebView().Scheduler()->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::ADVANCE);
+ WebViewScheduler::VirtualTimePolicy::kAdvance);
// Schedule normal DOM timers to run at 1s and 1.001s in the future.
ExecuteJavaScript(
@@ -228,14 +228,15 @@
Window().GetExecutionContext()->GetTaskRunner(TaskType::kJavascriptTimer);
// Schedule a task to suspend virtual time at the same point in time.
- runner->PostDelayedTask(BLINK_FROM_HERE,
- WTF::Bind(
- [](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(
- WebViewScheduler::VirtualTimePolicy::PAUSE);
- },
- WTF::Unretained(WebView().Scheduler())),
- TimeDelta::FromMilliseconds(1000));
+ runner->PostDelayedTask(
+ BLINK_FROM_HERE,
+ WTF::Bind(
+ [](WebViewScheduler* scheduler) {
+ scheduler->SetVirtualTimePolicy(
+ WebViewScheduler::VirtualTimePolicy::kPause);
+ },
+ WTF::Unretained(WebView().Scheduler())),
+ TimeDelta::FromMilliseconds(1000));
// ALso schedule a third timer for the same point in time.
ExecuteJavaScript("setTimeout(() => { run_order.push(2); }, 1000);");
diff --git a/third_party/WebKit/Source/platform/TimerTest.cpp b/third_party/WebKit/Source/platform/TimerTest.cpp
index 8929aea0..70182cb 100644
--- a/third_party/WebKit/Source/platform/TimerTest.cpp
+++ b/third_party/WebKit/Source/platform/TimerTest.cpp
@@ -539,7 +539,7 @@
TEST_F(TimerTest, UserSuppliedWebTaskRunner) {
scoped_refptr<scheduler::TaskQueue> task_runner(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner =
scheduler::WebTaskRunnerImpl::Create(task_runner);
TimerForTest<TimerTest> timer(web_task_runner, this,
@@ -630,7 +630,7 @@
scoped_refptr<scheduler::TaskQueue> task_runner1(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
scheduler::WebTaskRunnerImpl::Create(task_runner1);
TaskObserver task_observer1(web_task_runner1, &run_order);
@@ -638,7 +638,7 @@
scoped_refptr<scheduler::TaskQueue> task_runner2(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
scheduler::WebTaskRunnerImpl::Create(task_runner2);
TaskObserver task_observer2(web_task_runner2, &run_order);
@@ -670,7 +670,7 @@
scoped_refptr<scheduler::TaskQueue> task_runner1(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
scheduler::WebTaskRunnerImpl::Create(task_runner1);
TaskObserver task_observer1(web_task_runner1, &run_order);
@@ -678,7 +678,7 @@
scoped_refptr<scheduler::TaskQueue> task_runner2(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
scheduler::WebTaskRunnerImpl::Create(task_runner2);
TaskObserver task_observer2(web_task_runner2, &run_order);
@@ -712,13 +712,13 @@
TEST_F(TimerTest, MoveToNewTaskRunnerWithoutTasks) {
scoped_refptr<scheduler::TaskQueue> task_runner1(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner1 =
scheduler::WebTaskRunnerImpl::Create(task_runner1);
scoped_refptr<scheduler::TaskQueue> task_runner2(
platform_->GetRendererScheduler()->NewTimerTaskQueue(
- scheduler::MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE));
+ scheduler::MainThreadTaskQueue::QueueType::kFrameThrottleable));
scoped_refptr<scheduler::WebTaskRunnerImpl> web_task_runner2 =
scheduler::WebTaskRunnerImpl::Create(task_runner2);
diff --git a/third_party/WebKit/Source/platform/scheduler/README.md b/third_party/WebKit/Source/platform/scheduler/README.md
index 45b4e67..4c050c2 100644
--- a/third_party/WebKit/Source/platform/scheduler/README.md
+++ b/third_party/WebKit/Source/platform/scheduler/README.md
@@ -29,7 +29,7 @@
## 2016
* [Time-based renderer task throttling](https://drive.google.com/open?id=1vCUeGfr2xzZ67SFt2yZjNeaIcXGp2Td6KHN7bI02ySo)
-* [V8 Performance Mode](https://drive.google.com/open?id=1bRVAP08qNBvnEm_vO4hW1-NqQC9-lQZjUH29_vwfYRY)
+* [kV8 Performance Mode](https://drive.google.com/open?id=1bRVAP08qNBvnEm_vO4hW1-NqQC9-lQZjUH29_vwfYRY)
* [Isolating performance of third-party iframes](https://docs.google.com/document/d/1CEggurHQGXenhu_GQT7KnRvtSuowuenXpxVzYSeRxSY/edit)
* [Folly of Scheduling (BlinkOn 6)](https://drive.google.com/open?id=1ZMxbnSn1R1o2-NGztP0mVyOOoQg24bLSqWE1SWXnQ_E)
* [Rendering pipeline throttling (BlinkOn 6)](https://docs.google.com/presentation/d/1aPZzH7J0O29sqA_FzsuWQNDwK6CoNcAcpMvJexsO6Vg/edit)
diff --git a/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.cc b/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.cc
index fcfd3ffd..f2570877 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.cc
@@ -11,7 +11,7 @@
// Note we set the first |enqueue_order_| to a specific non-zero value, because
// first N values of EnqueueOrder have special meaning (see EnqueueOrderValues).
EnqueueOrderGenerator::EnqueueOrderGenerator()
- : enqueue_order_(static_cast<EnqueueOrder>(EnqueueOrderValues::FIRST)) {}
+ : enqueue_order_(static_cast<EnqueueOrder>(EnqueueOrderValues::kFirst)) {}
EnqueueOrderGenerator::~EnqueueOrderGenerator() {}
diff --git a/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.h b/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.h
index 04932d5..05c47d4 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/enqueue_order.h
@@ -18,11 +18,11 @@
// TODO(scheduler-dev): Remove explicit casts when c++17 comes.
enum class EnqueueOrderValues : EnqueueOrder {
// Invalid EnqueueOrder.
- NONE = 0,
+ kNone = 0,
// Earliest possible EnqueueOrder, to be used for fence blocking.
- BLOCKING_FENCE = 1,
- FIRST = 2,
+ kBlockingFence = 1,
+ kFirst = 2,
};
// A 64bit integer used to provide ordering of tasks. NOTE The scheduler assumes
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue.cc
index 53f1541..34db6e13 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue.cc
@@ -146,7 +146,7 @@
TaskQueue::QueuePriority TaskQueue::GetQueuePriority() const {
DCHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
if (!impl_)
- return TaskQueue::QueuePriority::LOW_PRIORITY;
+ return TaskQueue::QueuePriority::kLowPriority;
return impl_->GetQueuePriority();
}
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue.h b/third_party/WebKit/Source/platform/scheduler/base/task_queue.h
index 59bd7b3..9dc954a 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue.h
@@ -78,23 +78,23 @@
// Queues with control priority will run before any other queue, and will
// explicitly starve other queues. Typically this should only be used for
// private queues which perform control operations.
- CONTROL_PRIORITY,
+ kControlPriority,
// The selector will prioritize high over normal and low and normal over
// low. However it will ensure neither of the lower priority queues can be
// completely starved by higher priority tasks. All three of these queues
// will always take priority over and can starve the best effort queue.
- HIGH_PRIORITY,
+ kHighPriority,
// Queues with normal priority are the default.
- NORMAL_PRIORITY,
- LOW_PRIORITY,
+ kNormalPriority,
+ kLowPriority,
// Queues with best effort priority will only be run if all other queues are
// empty. They can be starved by the other queues.
- BEST_EFFORT_PRIORITY,
+ kBestEffortPriority,
// Must be the last entry.
- QUEUE_PRIORITY_COUNT,
- FIRST_QUEUE_PRIORITY = CONTROL_PRIORITY,
+ kQueuePriorityCount,
+ kFirstQueuePriority = kControlPriority,
};
// Can be called on any thread.
@@ -219,9 +219,9 @@
TimeDomain* GetTimeDomain() const;
enum class InsertFencePosition {
- NOW, // Tasks posted on the queue up till this point further may run.
- // All further tasks are blocked.
- BEGINNING_OF_TIME, // No tasks posted on this queue may run.
+ kNow, // Tasks posted on the queue up till this point further may run.
+ // All further tasks are blocked.
+ kBeginningOfTime, // No tasks posted on this queue may run.
};
// Inserts a barrier into the task queue which prevents tasks with an enqueue
@@ -233,7 +233,7 @@
// Fences come in three flavours:
// - Regular (InsertFence(NOW)) - all tasks posted after this moment
// are blocked.
- // - Fully blocking (InsertFence(BEGINNING_OF_TIME)) - all tasks including
+ // - Fully blocking (InsertFence(kBeginningOfTime)) - all tasks including
// already posted are blocked.
// - Delayed (InsertFenceAt(timestamp)) - blocks all tasks posted after given
// point in time (must be in the future).
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index 44395f6..49c3fd5 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
@@ -22,15 +22,15 @@
// static
const char* TaskQueue::PriorityToString(TaskQueue::QueuePriority priority) {
switch (priority) {
- case CONTROL_PRIORITY:
+ case kControlPriority:
return "control";
- case HIGH_PRIORITY:
+ case kHighPriority:
return "high";
- case NORMAL_PRIORITY:
+ case kNormalPriority:
return "normal";
- case LOW_PRIORITY:
+ case kLowPriority:
return "low";
- case BEST_EFFORT_PRIORITY:
+ case kBestEffortPriority:
return "best_effort";
default:
NOTREACHED();
@@ -102,10 +102,10 @@
: task_queue_manager(task_queue_manager),
time_domain(time_domain),
delayed_work_queue(
- new WorkQueue(task_queue, "delayed", WorkQueue::QueueType::DELAYED)),
+ new WorkQueue(task_queue, "delayed", WorkQueue::QueueType::kDelayed)),
immediate_work_queue(new WorkQueue(task_queue,
"immediate",
- WorkQueue::QueueType::IMMEDIATE)),
+ WorkQueue::QueueType::kImmediate)),
set_index(0),
is_enabled_refcount(0),
voter_refcount(0),
@@ -319,7 +319,7 @@
if (task.delayed_run_time >= main_thread_only().delayed_fence.value()) {
main_thread_only().delayed_fence = base::nullopt;
DCHECK_EQ(main_thread_only().current_fence,
- static_cast<EnqueueOrder>(EnqueueOrderValues::NONE));
+ static_cast<EnqueueOrder>(EnqueueOrderValues::kNone));
bool task_unblocked = InsertFenceImpl(task.enqueue_order());
DCHECK(!task_unblocked)
<< "Activating a delayed fence shouldn't unblock new work";
@@ -576,9 +576,9 @@
EnqueueOrder previous_fence = main_thread_only().current_fence;
EnqueueOrder current_fence =
- position == TaskQueue::InsertFencePosition::NOW
+ position == TaskQueue::InsertFencePosition::kNow
? main_thread_only().task_queue_manager->GetNextSequenceNumber()
- : static_cast<EnqueueOrder>(EnqueueOrderValues::BLOCKING_FENCE);
+ : static_cast<EnqueueOrder>(EnqueueOrderValues::kBlockingFence);
// Tasks posted after this point will have a strictly higher enqueue order
// and will be blocked from running.
@@ -960,7 +960,7 @@
return;
if (main_thread_only().delayed_fence.value() > now)
return;
- InsertFence(TaskQueue::InsertFencePosition::NOW);
+ InsertFence(TaskQueue::InsertFencePosition::kNow);
main_thread_only().delayed_fence = base::nullopt;
}
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
index 6e1cb435..b6a702f4 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
@@ -322,12 +322,12 @@
base::TimeTicks time_after_task;
switch (ProcessTaskFromWorkQueue(work_queue, is_nested, lazy_now,
&time_after_task)) {
- case ProcessTaskResult::DEFERRED:
+ case ProcessTaskResult::kDeferred:
// If a task was deferred, try again with another task.
continue;
- case ProcessTaskResult::EXECUTED:
+ case ProcessTaskResult::kExecuted:
break;
- case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
+ case ProcessTaskResult::kTaskQueueManagerDeleted:
return; // The TaskQueueManager got deleted, we must bail out.
}
@@ -484,7 +484,7 @@
// It's possible the task was canceled, if so bail out.
if (pending_task.task.IsCancelled())
- return ProcessTaskResult::EXECUTED;
+ return ProcessTaskResult::kExecuted;
internal::TaskQueueImpl* queue = work_queue->task_queue();
if (queue->GetQuiescenceMonitored())
@@ -500,7 +500,7 @@
delegate_->PostNonNestableTask(
pending_task.posted_from,
UnsafeConvertOnceClosureToRepeating(std::move(pending_task.task)));
- return ProcessTaskResult::DEFERRED;
+ return ProcessTaskResult::kDeferred;
}
double task_start_time_sec = 0;
@@ -536,7 +536,7 @@
// Detect if the TaskQueueManager just got deleted. If this happens we must
// not access any member variables after this point.
if (!protect)
- return ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED;
+ return ProcessTaskResult::kTaskQueueManagerDeleted;
currently_executing_task_queue_ = prev_executing_task_queue;
@@ -564,7 +564,7 @@
"duration", task_end_time_sec - task_start_time_sec);
}
- return ProcessTaskResult::EXECUTED;
+ return ProcessTaskResult::kExecuted;
}
bool TaskQueueManager::RunsTasksInCurrentSequence() const {
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h
index 3aca257..95288ab 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h
@@ -274,9 +274,9 @@
bool SelectWorkQueueToService(internal::WorkQueue** out_work_queue);
enum class ProcessTaskResult {
- DEFERRED,
- EXECUTED,
- TASK_QUEUE_MANAGER_DELETED
+ kDeferred,
+ kExecuted,
+ kTaskQueueManagerDeleted,
};
// Runs a single nestable task from the |queue|. On exit, |out_task| will
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
index c7a7bd0..b6aca87 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.cc
@@ -563,7 +563,7 @@
TEST_F(TaskQueueManagerTest, InsertAndRemoveFence) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
// Posting a task when pumping is disabled doesn't result in work getting
@@ -588,7 +588,7 @@
std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
runners_[0]->CreateQueueEnabledVoter();
voter->SetQueueEnabled(false);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
runners_[0]->RemoveFence();
@@ -602,7 +602,7 @@
std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
runners_[0]->CreateQueueEnabledVoter();
voter->SetQueueEnabled(false);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
voter->SetQueueEnabled(true);
@@ -649,7 +649,7 @@
Initialize(1u);
std::vector<EnqueueOrder> run_order;
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
runners_[0]->CreateQueueEnabledVoter();
voter->SetQueueEnabled(false);
@@ -666,7 +666,7 @@
TEST_F(TaskQueueManagerTest, RemovingFenceWithDelayedTask) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
// Posting a delayed task when fenced will apply the delay, but won't cause
@@ -688,7 +688,7 @@
TEST_F(TaskQueueManagerTest, RemovingFenceWithMultipleDelayedTasks) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
// Posting a delayed task when fenced will apply the delay, but won't cause
@@ -715,7 +715,7 @@
TEST_F(TaskQueueManagerTest, InsertFencePreventsDelayedTasksFromRunning) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
@@ -732,13 +732,13 @@
std::vector<EnqueueOrder> run_order;
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
test_task_runner_->RunUntilIdle();
EXPECT_THAT(run_order, ElementsAre(1, 2));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
// Subsequent tasks should be blocked.
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
test_task_runner_->RunUntilIdle();
@@ -747,7 +747,7 @@
TEST_F(TaskQueueManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->RemoveFence();
std::vector<EnqueueOrder> run_order;
@@ -760,7 +760,7 @@
TEST_F(TaskQueueManagerTest, InsertFencePostThenRemoveDoesNotBlock) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
@@ -773,11 +773,11 @@
TEST_F(TaskQueueManagerTest, MultipleFencesWithInitiallyEmptyQueue) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
std::vector<EnqueueOrder> run_order;
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
test_task_runner_->RunUntilIdle();
EXPECT_THAT(run_order, ElementsAre(1));
@@ -787,14 +787,14 @@
Initialize(1u);
EXPECT_FALSE(runners_[0]->BlockedByFence());
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EXPECT_TRUE(runners_[0]->BlockedByFence());
runners_[0]->RemoveFence();
EXPECT_FALSE(runners_[0]->BlockedByFence());
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EXPECT_FALSE(runners_[0]->BlockedByFence());
test_task_runner_->RunUntilIdle();
@@ -809,10 +809,10 @@
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EXPECT_FALSE(runners_[0]->BlockedByFence());
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
EXPECT_TRUE(runners_[0]->BlockedByFence());
}
@@ -2665,7 +2665,7 @@
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_Fence) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
LazyNow lazy_now(now_src_.get());
@@ -2675,9 +2675,9 @@
TEST_F(TaskQueueManagerTest, ComputeDelayTillNextTask_FenceUnblocking) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
LazyNow lazy_now(now_src_.get());
EXPECT_EQ(base::TimeDelta(), ComputeDelayTillNextTask(&lazy_now)->Delay());
@@ -2898,10 +2898,10 @@
EnqueueOrder enqueue_order = GetNextSequenceNumber();
EXPECT_TRUE(runners_[0]->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EXPECT_TRUE(runners_[0]->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
EXPECT_FALSE(runners_[0]->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
runners_[0]->RemoveFence();
@@ -2911,12 +2911,12 @@
TEST_F(TaskQueueManagerTest, CouldTaskRun_FenceBeforeThenAfter) {
Initialize(1u);
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EnqueueOrder enqueue_order = GetNextSequenceNumber();
EXPECT_FALSE(runners_[0]->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kNow);
EXPECT_TRUE(runners_[0]->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
}
@@ -3009,7 +3009,7 @@
EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
// Neither should fences.
- runners_[0]->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ runners_[0]->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
EXPECT_EQ(start_time + delay2, runners_[0]->GetNextScheduledWakeUp());
}
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc
index 4afaf35..6692854 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector.cc
@@ -27,7 +27,7 @@
void TaskQueueSelector::AddQueue(internal::TaskQueueImpl* queue) {
DCHECK(main_thread_checker_.CalledOnValidThread());
DCHECK(queue->IsQueueEnabled());
- enabled_selector_.AddQueue(queue, TaskQueue::NORMAL_PRIORITY);
+ enabled_selector_.AddQueue(queue, TaskQueue::kNormalPriority);
}
void TaskQueueSelector::RemoveQueue(internal::TaskQueueImpl* queue) {
@@ -74,7 +74,7 @@
void TaskQueueSelector::SetQueuePriority(internal::TaskQueueImpl* queue,
TaskQueue::QueuePriority priority) {
- DCHECK_LT(priority, TaskQueue::QUEUE_PRIORITY_COUNT);
+ DCHECK_LT(priority, TaskQueue::kQueuePriorityCount);
DCHECK(main_thread_checker_.CalledOnValidThread());
if (queue->IsQueueEnabled()) {
enabled_selector_.ChangeSetIndex(queue, priority);
@@ -92,7 +92,7 @@
TaskQueue::QueuePriority TaskQueueSelector::NextPriority(
TaskQueue::QueuePriority priority) {
- DCHECK(priority < TaskQueue::QUEUE_PRIORITY_COUNT);
+ DCHECK(priority < TaskQueue::kQueuePriorityCount);
return static_cast<TaskQueue::QueuePriority>(static_cast<int>(priority) + 1);
}
@@ -100,8 +100,8 @@
TaskQueueSelector* task_queue_selector,
const char* name)
: task_queue_selector_(task_queue_selector),
- delayed_work_queue_sets_(TaskQueue::QUEUE_PRIORITY_COUNT, name),
- immediate_work_queue_sets_(TaskQueue::QUEUE_PRIORITY_COUNT, name) {}
+ delayed_work_queue_sets_(TaskQueue::kQueuePriorityCount, name),
+ immediate_work_queue_sets_(TaskQueue::kQueuePriorityCount, name) {}
void TaskQueueSelector::PrioritizingSelector::AddQueue(
internal::TaskQueueImpl* queue,
@@ -208,33 +208,33 @@
DCHECK_EQ(*out_chose_delayed_over_immediate, false);
// Always service the control queue if it has any work.
- if (max_priority > TaskQueue::CONTROL_PRIORITY &&
- ChooseOldestWithPriority(TaskQueue::CONTROL_PRIORITY,
+ if (max_priority > TaskQueue::kControlPriority &&
+ ChooseOldestWithPriority(TaskQueue::kControlPriority,
out_chose_delayed_over_immediate,
out_work_queue)) {
return true;
}
// Select from the low priority queue if we are starving it.
- if (max_priority > TaskQueue::LOW_PRIORITY &&
+ if (max_priority > TaskQueue::kLowPriority &&
task_queue_selector_->low_priority_starvation_score_ >=
kMaxLowPriorityStarvationScore &&
- ChooseOldestWithPriority(TaskQueue::LOW_PRIORITY,
+ ChooseOldestWithPriority(TaskQueue::kLowPriority,
out_chose_delayed_over_immediate,
out_work_queue)) {
return true;
}
// Select from the normal priority queue if we are starving it.
- if (max_priority > TaskQueue::NORMAL_PRIORITY &&
+ if (max_priority > TaskQueue::kNormalPriority &&
task_queue_selector_->normal_priority_starvation_score_ >=
kMaxNormalPriorityStarvationScore &&
- ChooseOldestWithPriority(TaskQueue::NORMAL_PRIORITY,
+ ChooseOldestWithPriority(TaskQueue::kNormalPriority,
out_chose_delayed_over_immediate,
out_work_queue)) {
return true;
}
// Otherwise choose in priority order.
- for (TaskQueue::QueuePriority priority = TaskQueue::HIGH_PRIORITY;
+ for (TaskQueue::QueuePriority priority = TaskQueue::kHighPriority;
priority < max_priority; priority = NextPriority(priority)) {
if (ChooseOldestWithPriority(priority, out_chose_delayed_over_immediate,
out_work_queue)) {
@@ -264,7 +264,7 @@
DCHECK(main_thread_checker_.CalledOnValidThread());
bool chose_delayed_over_immediate = false;
bool found_queue = enabled_selector_.SelectWorkQueueToService(
- TaskQueue::QUEUE_PRIORITY_COUNT, out_work_queue,
+ TaskQueue::kQueuePriorityCount, out_work_queue,
&chose_delayed_over_immediate);
if (!found_queue) {
TrySelectingBlockedQueue();
@@ -287,7 +287,7 @@
// There was nothing unblocked to run, see if we could have run a blocked
// task.
if (blocked_selector_.SelectWorkQueueToService(
- TaskQueue::QUEUE_PRIORITY_COUNT, &chosen_blocked_queue,
+ TaskQueue::kQueuePriorityCount, &chosen_blocked_queue,
&chose_delayed_over_immediate)) {
task_queue_selector_observer_->OnTriedToSelectBlockedWorkQueue(
chosen_blocked_queue);
@@ -333,21 +333,21 @@
TaskQueue::QueuePriority priority,
bool chose_delayed_over_immediate) {
switch (priority) {
- case TaskQueue::CONTROL_PRIORITY:
+ case TaskQueue::kControlPriority:
break;
- case TaskQueue::HIGH_PRIORITY:
+ case TaskQueue::kHighPriority:
low_priority_starvation_score_ +=
kSmallScoreIncrementForLowPriorityStarvation;
normal_priority_starvation_score_ +=
kSmallScoreIncrementForNormalPriorityStarvation;
break;
- case TaskQueue::NORMAL_PRIORITY:
+ case TaskQueue::kNormalPriority:
low_priority_starvation_score_ +=
kLargeScoreIncrementForLowPriorityStarvation;
normal_priority_starvation_score_ = 0;
break;
- case TaskQueue::LOW_PRIORITY:
- case TaskQueue::BEST_EFFORT_PRIORITY:
+ case TaskQueue::kLowPriority:
+ case TaskQueue::kBestEffortPriority:
low_priority_starvation_score_ = 0;
normal_priority_starvation_score_ = 0;
break;
@@ -379,8 +379,8 @@
bool TaskQueueSelector::EnabledWorkQueuesEmpty() const {
DCHECK(main_thread_checker_.CalledOnValidThread());
- for (TaskQueue::QueuePriority priority = TaskQueue::CONTROL_PRIORITY;
- priority < TaskQueue::QUEUE_PRIORITY_COUNT;
+ for (TaskQueue::QueuePriority priority = TaskQueue::kControlPriority;
+ priority < TaskQueue::kQueuePriorityCount;
priority = NextPriority(priority)) {
if (!enabled_selector_.delayed_work_queue_sets()->IsSetEmpty(priority) ||
!enabled_selector_.immediate_work_queue_sets()->IsSetEmpty(priority)) {
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc
index 629c4824..44f376d3 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_selector_unittest.cc
@@ -112,7 +112,7 @@
task_queues_.push_back(std::move(task_queue));
}
for (size_t i = 0; i < kTaskQueueCount; i++) {
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[i]->GetQueuePriority())
+ EXPECT_EQ(TaskQueue::kNormalPriority, task_queues_[i]->GetQueuePriority())
<< i;
queue_to_index_map_.insert(std::make_pair(task_queues_[i].get(), i));
}
@@ -151,14 +151,14 @@
TEST_F(TaskQueueSelectorTest, TestHighPriority) {
size_t queue_order[] = {0, 1, 2, 3, 4};
PushTasks(queue_order, 5);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2, 0, 1, 3, 4));
}
TEST_F(TaskQueueSelectorTest, TestLowPriority) {
size_t queue_order[] = {0, 1, 2, 3, 4};
PushTasks(queue_order, 5);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::LOW_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kLowPriority);
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(0, 1, 3, 4, 2));
}
@@ -166,9 +166,9 @@
size_t queue_order[] = {0, 1, 2, 3, 4};
PushTasks(queue_order, 5);
selector_.SetQueuePriority(task_queues_[0].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::LOW_PRIORITY);
- selector_.SetQueuePriority(task_queues_[3].get(), TaskQueue::HIGH_PRIORITY);
+ TaskQueue::kBestEffortPriority);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kLowPriority);
+ selector_.SetQueuePriority(task_queues_[3].get(), TaskQueue::kHighPriority);
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(3, 1, 4, 2, 0));
}
@@ -176,10 +176,10 @@
size_t queue_order[] = {0, 1, 2, 3, 4};
PushTasks(queue_order, 5);
selector_.SetQueuePriority(task_queues_[4].get(),
- TaskQueue::CONTROL_PRIORITY);
- EXPECT_EQ(TaskQueue::CONTROL_PRIORITY, task_queues_[4]->GetQueuePriority());
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
- EXPECT_EQ(TaskQueue::HIGH_PRIORITY, task_queues_[2]->GetQueuePriority());
+ TaskQueue::kControlPriority);
+ EXPECT_EQ(TaskQueue::kControlPriority, task_queues_[4]->GetQueuePriority());
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
+ EXPECT_EQ(TaskQueue::kHighPriority, task_queues_[2]->GetQueuePriority());
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(4, 2, 0, 1, 3));
}
@@ -195,11 +195,11 @@
TEST_F(TaskQueueSelectorTest,
TestObserverWithSetQueuePriorityAndQueueAlreadyEnabled) {
- selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::HIGH_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::kHighPriority);
MockObserver mock_observer;
selector_.SetTaskQueueSelectorObserver(&mock_observer);
EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(0);
- selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::NORMAL_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::kNormalPriority);
}
TEST_F(TaskQueueSelectorTest, TestDisableEnable) {
@@ -213,15 +213,15 @@
task_queues_[4]->SetQueueEnabledForTest(false);
selector_.DisableQueue(task_queues_[4].get());
// Disabling a queue should not affect its priority.
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[2]->GetQueuePriority());
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[4]->GetQueuePriority());
+ EXPECT_EQ(TaskQueue::kNormalPriority, task_queues_[2]->GetQueuePriority());
+ EXPECT_EQ(TaskQueue::kNormalPriority, task_queues_[4]->GetQueuePriority());
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(0, 1, 3));
EXPECT_CALL(mock_observer, OnTaskQueueEnabled(_)).Times(2);
task_queues_[2]->SetQueueEnabledForTest(true);
selector_.EnableQueue(task_queues_[2].get());
selector_.SetQueuePriority(task_queues_[2].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
+ TaskQueue::kBestEffortPriority);
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2));
task_queues_[4]->SetQueueEnabledForTest(true);
selector_.EnableQueue(task_queues_[4].get());
@@ -233,7 +233,7 @@
EXPECT_TRUE(task_queues_[2]->immediate_work_queue()->Empty());
task_queues_[2]->SetQueueEnabledForTest(false);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
size_t queue_order[] = {0, 1, 2, 3, 4};
PushTasks(queue_order, 5);
@@ -242,7 +242,7 @@
EXPECT_FALSE(task_queues_[2]->immediate_work_queue()->Empty());
task_queues_[2]->SetQueueEnabledForTest(true);
- EXPECT_EQ(TaskQueue::HIGH_PRIORITY, task_queues_[2]->GetQueuePriority());
+ EXPECT_EQ(TaskQueue::kHighPriority, task_queues_[2]->GetQueuePriority());
EXPECT_THAT(PopTasks(), ::testing::ElementsAre(2, 0, 1, 3, 4));
}
@@ -275,10 +275,10 @@
size_t queue_order[] = {0, 1, 2, 3};
PushTasks(queue_order, 4);
selector_.SetQueuePriority(task_queues_[3].get(),
- TaskQueue::CONTROL_PRIORITY);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
+ TaskQueue::kControlPriority);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
selector_.SetQueuePriority(task_queues_[1].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
+ TaskQueue::kBestEffortPriority);
for (int i = 0; i < 100; i++) {
WorkQueue* chosen_work_queue = nullptr;
ASSERT_TRUE(selector_.SelectWorkQueueToService(&chosen_work_queue));
@@ -290,9 +290,9 @@
TEST_F(TaskQueueSelectorTest, TestHighPriorityDoesNotStarveNormal) {
size_t queue_order[] = {0, 1, 2};
PushTasks(queue_order, 3);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
selector_.SetQueuePriority(task_queues_[1].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
+ TaskQueue::kBestEffortPriority);
size_t counts[] = {0, 0, 0};
for (int i = 0; i < 100; i++) {
WorkQueue* chosen_work_queue = nullptr;
@@ -310,8 +310,8 @@
TEST_F(TaskQueueSelectorTest, TestHighPriorityDoesNotStarveNormalOrLow) {
size_t queue_order[] = {0, 1, 2};
PushTasks(queue_order, 3);
- selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::HIGH_PRIORITY);
- selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::LOW_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[2].get(), TaskQueue::kHighPriority);
+ selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::kLowPriority);
size_t counts[] = {0, 0, 0};
for (int i = 0; i < 100; i++) {
WorkQueue* chosen_work_queue = nullptr;
@@ -330,9 +330,9 @@
TEST_F(TaskQueueSelectorTest, TestNormalPriorityDoesNotStarveLow) {
size_t queue_order[] = {0, 1, 2};
PushTasks(queue_order, 3);
- selector_.SetQueuePriority(task_queues_[0].get(), TaskQueue::LOW_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[0].get(), TaskQueue::kLowPriority);
selector_.SetQueuePriority(task_queues_[1].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
+ TaskQueue::kBestEffortPriority);
size_t counts[] = {0, 0, 0};
for (int i = 0; i < 100; i++) {
WorkQueue* chosen_work_queue = nullptr;
@@ -351,22 +351,22 @@
size_t queue_order[] = {0, 1};
PushTasks(queue_order, 2);
selector_.SetQueuePriority(task_queues_[0].get(),
- TaskQueue::BEST_EFFORT_PRIORITY);
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY, task_queues_[1]->GetQueuePriority());
+ TaskQueue::kBestEffortPriority);
+ EXPECT_EQ(TaskQueue::kNormalPriority, task_queues_[1]->GetQueuePriority());
WorkQueue* chosen_work_queue = nullptr;
for (int i = 0; i < 100; i++) {
ASSERT_TRUE(selector_.SelectWorkQueueToService(&chosen_work_queue));
EXPECT_EQ(task_queues_[1].get(), chosen_work_queue->task_queue());
// Don't remove task from queue to simulate all queues still being full.
}
- selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::HIGH_PRIORITY);
+ selector_.SetQueuePriority(task_queues_[1].get(), TaskQueue::kHighPriority);
for (int i = 0; i < 100; i++) {
ASSERT_TRUE(selector_.SelectWorkQueueToService(&chosen_work_queue));
EXPECT_EQ(task_queues_[1].get(), chosen_work_queue->task_queue());
// Don't remove task from queue to simulate all queues still being full.
}
selector_.SetQueuePriority(task_queues_[1].get(),
- TaskQueue::CONTROL_PRIORITY);
+ TaskQueue::kControlPriority);
for (int i = 0; i < 100; i++) {
ASSERT_TRUE(selector_.SelectWorkQueueToService(&chosen_work_queue));
EXPECT_EQ(task_queues_[1].get(), chosen_work_queue->task_queue());
@@ -389,7 +389,7 @@
PushTasks(queue_order, 1);
selector_.SetQueuePriority(task_queues_[0].get(),
- TaskQueue::CONTROL_PRIORITY);
+ TaskQueue::kControlPriority);
EXPECT_FALSE(selector_.EnabledWorkQueuesEmpty());
}
@@ -398,7 +398,7 @@
WorkQueue* chosen_work_queue = nullptr;
bool chose_delayed_over_immediate = false;
EXPECT_FALSE(enabled_selector()->ChooseOldestWithPriority(
- TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
+ TaskQueue::kNormalPriority, &chose_delayed_over_immediate,
&chosen_work_queue));
EXPECT_FALSE(chose_delayed_over_immediate);
}
@@ -411,7 +411,7 @@
WorkQueue* chosen_work_queue = nullptr;
bool chose_delayed_over_immediate = false;
EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
- TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
+ TaskQueue::kNormalPriority, &chose_delayed_over_immediate,
&chosen_work_queue));
EXPECT_EQ(chosen_work_queue, task_queues_[0]->delayed_work_queue());
EXPECT_FALSE(chose_delayed_over_immediate);
@@ -425,7 +425,7 @@
WorkQueue* chosen_work_queue = nullptr;
bool chose_delayed_over_immediate = false;
EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
- TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
+ TaskQueue::kNormalPriority, &chose_delayed_over_immediate,
&chosen_work_queue));
EXPECT_EQ(chosen_work_queue, task_queues_[0]->immediate_work_queue());
EXPECT_FALSE(chose_delayed_over_immediate);
@@ -474,7 +474,7 @@
selector.DisableQueue(task_queue.get());
selector.DisableQueue(task_queue2.get());
- selector.SetQueuePriority(task_queue2.get(), TaskQueue::CONTROL_PRIORITY);
+ selector.SetQueuePriority(task_queue2.get(), TaskQueue::kControlPriority);
TaskQueueImpl::Task task1(TaskQueue::PostedTask(test_closure_, FROM_HERE),
base::TimeTicks(), 0);
@@ -547,7 +547,7 @@
WorkQueue* chosen_work_queue = nullptr;
bool chose_delayed_over_immediate = false;
EXPECT_TRUE(enabled_selector()->ChooseOldestWithPriority(
- TaskQueue::NORMAL_PRIORITY, &chose_delayed_over_immediate,
+ TaskQueue::kNormalPriority, &chose_delayed_over_immediate,
&chosen_work_queue));
EXPECT_EQ(chosen_work_queue->task_queue(), task_queues_[0].get());
EXPECT_STREQ(chosen_work_queue->name(), GetParam().expected_work_queue_name);
diff --git a/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc b/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc
index 69f93cb..e28f4814c 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc
@@ -106,7 +106,7 @@
TaskQueueImpl::Task pending_task = work_queue_.TakeFirst();
// NB immediate tasks have a different pipeline to delayed ones.
- if (queue_type_ == QueueType::IMMEDIATE && work_queue_.empty()) {
+ if (queue_type_ == QueueType::kImmediate && work_queue_.empty()) {
// Short-circuit the queue reload so that OnPopQueue does the right thing.
work_queue_ = task_queue_->TakeImmediateIncomingQueue();
}
diff --git a/third_party/WebKit/Source/platform/scheduler/base/work_queue.h b/third_party/WebKit/Source/platform/scheduler/base/work_queue.h
index ed4217de..06604adc 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/work_queue.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/work_queue.h
@@ -32,7 +32,7 @@
// throttling mechanisms.
class PLATFORM_EXPORT WorkQueue {
public:
- enum class QueueType { DELAYED, IMMEDIATE };
+ enum class QueueType { kDelayed, kImmediate };
WorkQueue(TaskQueueImpl* task_queue, const char* name, QueueType queue_type);
~WorkQueue();
diff --git a/third_party/WebKit/Source/platform/scheduler/base/work_queue_sets_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/work_queue_sets_unittest.cc
index b927eb2..1879bed 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/work_queue_sets_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/work_queue_sets_unittest.cc
@@ -36,9 +36,9 @@
WorkQueue* NewTaskQueue(const char* queue_name) {
WorkQueue* queue =
- new WorkQueue(nullptr, "test", WorkQueue::QueueType::IMMEDIATE);
+ new WorkQueue(nullptr, "test", WorkQueue::QueueType::kImmediate);
work_queues_.push_back(base::WrapUnique(queue));
- work_queue_sets_->AddQueue(queue, TaskQueue::CONTROL_PRIORITY);
+ work_queue_sets_->AddQueue(queue, TaskQueue::kControlPriority);
return queue;
}
@@ -56,7 +56,7 @@
TEST_F(WorkQueueSetsTest, ChangeSetIndex) {
WorkQueue* work_queue = NewTaskQueue("queue");
- size_t set = TaskQueue::NORMAL_PRIORITY;
+ size_t set = TaskQueue::kNormalPriority;
work_queue_sets_->ChangeSetIndex(work_queue, set);
EXPECT_EQ(set, work_queue->work_queue_set_index());
@@ -64,7 +64,7 @@
TEST_F(WorkQueueSetsTest, GetOldestQueueInSet_QueueEmpty) {
WorkQueue* work_queue = NewTaskQueue("queue");
- size_t set = TaskQueue::NORMAL_PRIORITY;
+ size_t set = TaskQueue::kNormalPriority;
work_queue_sets_->ChangeSetIndex(work_queue, set);
WorkQueue* selected_work_queue;
@@ -74,7 +74,7 @@
TEST_F(WorkQueueSetsTest, OnTaskPushedToEmptyQueue) {
WorkQueue* work_queue = NewTaskQueue("queue");
- size_t set = TaskQueue::NORMAL_PRIORITY;
+ size_t set = TaskQueue::kNormalPriority;
work_queue_sets_->ChangeSetIndex(work_queue, set);
WorkQueue* selected_work_queue;
@@ -281,7 +281,7 @@
queue1->Push(FakeTaskWithEnqueueOrder(8));
queue2->Push(FakeTaskWithEnqueueOrder(9));
- size_t set = TaskQueue::CONTROL_PRIORITY;
+ size_t set = TaskQueue::kControlPriority;
WorkQueue* selected_work_queue;
EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(set, &selected_work_queue));
diff --git a/third_party/WebKit/Source/platform/scheduler/base/work_queue_unittest.cc b/third_party/WebKit/Source/platform/scheduler/base/work_queue_unittest.cc
index 78495f2..52364b9 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/work_queue_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/work_queue_unittest.cc
@@ -28,7 +28,7 @@
TaskQueue::Spec("test"));
work_queue_.reset(new WorkQueue(task_queue_.get(), "test",
- WorkQueue::QueueType::IMMEDIATE));
+ WorkQueue::QueueType::kImmediate));
work_queue_sets_.reset(new WorkQueueSets(1, "test"));
work_queue_sets_->AddQueue(work_queue_.get(), 0);
}
diff --git a/third_party/WebKit/Source/platform/scheduler/child/idle_canceled_delayed_task_sweeper_unittest.cc b/third_party/WebKit/Source/platform/scheduler/child/idle_canceled_delayed_task_sweeper_unittest.cc
index 56147c5..cb34378 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/idle_canceled_delayed_task_sweeper_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/idle_canceled_delayed_task_sweeper_unittest.cc
@@ -45,7 +45,7 @@
base::TimeDelta::FromSeconds(30),
scheduler_helper_->NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::TEST)))),
+ MainThreadTaskQueue::QueueType::kTest)))),
idle_canceled_delayed_taks_sweeper_(
new IdleCanceledDelayedTaskSweeper(scheduler_helper_.get(),
idle_helper_->IdleTaskRunner())),
diff --git a/third_party/WebKit/Source/platform/scheduler/child/idle_helper.cc b/third_party/WebKit/Source/platform/scheduler/child/idle_helper.cc
index 1cf1884..905aec8 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/idle_helper.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/idle_helper.cc
@@ -40,8 +40,8 @@
base::MakeRefCounted<SingleThreadIdleTaskRunner>(idle_queue_, this);
// This fence will block any idle tasks from running.
- idle_queue_->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
- idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
+ idle_queue_->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
+ idle_queue_->SetQueuePriority(TaskQueue::kBestEffortPriority);
}
IdleHelper::~IdleHelper() {
@@ -75,7 +75,7 @@
if (!delegate_->CanEnterLongIdlePeriod(now,
next_long_idle_period_delay_out)) {
- return IdlePeriodState::NOT_IN_IDLE_PERIOD;
+ return IdlePeriodState::kNotInIdlePeriod;
}
base::TimeTicks next_pending_delayed_task;
@@ -95,17 +95,17 @@
base::TimeDelta::FromMilliseconds(kMinimumIdlePeriodDurationMillis)) {
*next_long_idle_period_delay_out = long_idle_period_duration;
if (!idle_queue_->HasTaskToRunImmediately()) {
- return IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED;
+ return IdlePeriodState::kInLongIdlePeriodPaused;
} else if (long_idle_period_duration == max_long_idle_period_duration) {
- return IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE;
+ return IdlePeriodState::kInLongIdlePeriodWithMaxDeadline;
} else {
- return IdlePeriodState::IN_LONG_IDLE_PERIOD;
+ return IdlePeriodState::kInLongIdlePeriod;
}
} else {
// If we can't start the idle period yet then try again after wake-up.
*next_long_idle_period_delay_out = base::TimeDelta::FromMilliseconds(
kRetryEnableLongIdlePeriodDelayMillis);
- return IdlePeriodState::NOT_IN_IDLE_PERIOD;
+ return IdlePeriodState::kNotInIdlePeriod;
}
}
@@ -185,7 +185,7 @@
// Use a fence to make sure any idle tasks posted after this point do not run
// until the next idle period and unblock existing tasks.
- idle_queue_->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ idle_queue_->InsertFence(TaskQueue::InsertFencePosition::kNow);
state_.UpdateState(new_state, idle_period_deadline, now);
}
@@ -208,8 +208,8 @@
helper_->RemoveTaskObserver(this);
// This fence will block any idle tasks from running.
- idle_queue_->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
- state_.UpdateState(IdlePeriodState::NOT_IN_IDLE_PERIOD, base::TimeTicks(),
+ idle_queue_->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
+ state_.UpdateState(IdlePeriodState::kNotInIdlePeriod, base::TimeTicks(),
base::TimeTicks());
}
@@ -223,8 +223,7 @@
DCHECK(IsInIdlePeriod(state_.idle_period_state()));
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
"DidProcessTask");
- if (state_.idle_period_state() !=
- IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED &&
+ if (state_.idle_period_state() != IdlePeriodState::kInLongIdlePeriodPaused &&
helper_->scheduler_tqm_delegate()->NowTicks() >=
state_.idle_period_deadline()) {
// If the idle period deadline has now been reached, either end the idle
@@ -232,8 +231,7 @@
if (IsInLongIdlePeriod(state_.idle_period_state())) {
EnableLongIdlePeriod();
} else {
- DCHECK(IdlePeriodState::IN_SHORT_IDLE_PERIOD ==
- state_.idle_period_state());
+ DCHECK(IdlePeriodState::kInShortIdlePeriod == state_.idle_period_state());
EndIdlePeriod();
}
}
@@ -249,7 +247,7 @@
if (!idle_queue_->HasTaskToRunImmediately()) {
// If there are no more idle tasks then pause long idle period ticks until a
// new idle task is posted.
- state_.UpdateState(IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED,
+ state_.UpdateState(IdlePeriodState::kInLongIdlePeriodPaused,
state_.idle_period_deadline(), base::TimeTicks());
} else if (idle_queue_->BlockedByFence()) {
// If there is still idle work to do then just start the next idle period.
@@ -293,8 +291,7 @@
if (is_shutdown_)
return;
delegate_->OnPendingTasksChanged(true);
- if (state_.idle_period_state() ==
- IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
+ if (state_.idle_period_state() == IdlePeriodState::kInLongIdlePeriodPaused) {
// Restart long idle period ticks.
helper_->ControlTaskQueue()->PostTask(
FROM_HERE, enable_next_long_idle_period_closure_.GetCallback());
@@ -325,14 +322,14 @@
// static
bool IdleHelper::IsInIdlePeriod(IdlePeriodState state) {
- return state != IdlePeriodState::NOT_IN_IDLE_PERIOD;
+ return state != IdlePeriodState::kNotInIdlePeriod;
}
// static
bool IdleHelper::IsInLongIdlePeriod(IdlePeriodState state) {
- return state == IdlePeriodState::IN_LONG_IDLE_PERIOD ||
- state == IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE ||
- state == IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED;
+ return state == IdlePeriodState::kInLongIdlePeriod ||
+ state == IdlePeriodState::kInLongIdlePeriodWithMaxDeadline ||
+ state == IdlePeriodState::kInLongIdlePeriodPaused;
}
bool IdleHelper::CanExceedIdleDeadlineIfRequired() const {
@@ -340,7 +337,7 @@
"CanExceedIdleDeadlineIfRequired");
helper_->CheckOnValidThread();
return state_.idle_period_state() ==
- IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE;
+ IdlePeriodState::kInLongIdlePeriodWithMaxDeadline;
}
IdleHelper::IdlePeriodState IdleHelper::SchedulerIdlePeriodState() const {
@@ -352,7 +349,7 @@
const char* idle_period_tracing_name)
: helper_(helper),
delegate_(delegate),
- idle_period_state_(IdlePeriodState::NOT_IN_IDLE_PERIOD),
+ idle_period_state_(IdlePeriodState::kNotInIdlePeriod),
idle_period_trace_event_started_(false),
running_idle_task_for_tracing_(false),
idle_period_tracing_name_(idle_period_tracing_name) {}
@@ -461,16 +458,16 @@
TRACE_EVENT_ASYNC_STEP_INTO0("renderer.scheduler",
idle_period_tracing_name_, this,
"RunningIdleTask");
- } else if (new_state == IdlePeriodState::IN_SHORT_IDLE_PERIOD) {
+ } else if (new_state == IdlePeriodState::kInShortIdlePeriod) {
TRACE_EVENT_ASYNC_STEP_INTO0("renderer.scheduler",
idle_period_tracing_name_, this,
"ShortIdlePeriod");
} else if (IsInLongIdlePeriod(new_state) &&
- new_state != IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
+ new_state != IdlePeriodState::kInLongIdlePeriodPaused) {
TRACE_EVENT_ASYNC_STEP_INTO0("renderer.scheduler",
idle_period_tracing_name_, this,
"LongIdlePeriod");
- } else if (new_state == IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
+ } else if (new_state == IdlePeriodState::kInLongIdlePeriodPaused) {
TRACE_EVENT_ASYNC_STEP_INTO0("renderer.scheduler",
idle_period_tracing_name_, this,
"LongIdlePeriodPaused");
@@ -486,15 +483,15 @@
const char* IdleHelper::IdlePeriodStateToString(
IdlePeriodState idle_period_state) {
switch (idle_period_state) {
- case IdlePeriodState::NOT_IN_IDLE_PERIOD:
+ case IdlePeriodState::kNotInIdlePeriod:
return "not_in_idle_period";
- case IdlePeriodState::IN_SHORT_IDLE_PERIOD:
+ case IdlePeriodState::kInShortIdlePeriod:
return "in_short_idle_period";
- case IdlePeriodState::IN_LONG_IDLE_PERIOD:
+ case IdlePeriodState::kInLongIdlePeriod:
return "in_long_idle_period";
- case IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE:
+ case IdlePeriodState::kInLongIdlePeriodWithMaxDeadline:
return "in_long_idle_period_with_max_deadline";
- case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
+ case IdlePeriodState::kInLongIdlePeriodPaused:
return "in_long_idle_period_paused";
default:
NOTREACHED();
diff --git a/third_party/WebKit/Source/platform/scheduler/child/idle_helper.h b/third_party/WebKit/Source/platform/scheduler/child/idle_helper.h
index d8eab8a..b498c22 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/idle_helper.h
+++ b/third_party/WebKit/Source/platform/scheduler/child/idle_helper.h
@@ -76,14 +76,14 @@
// Keep IdleHelper::IdlePeriodStateToString in sync with this enum.
enum class IdlePeriodState {
- NOT_IN_IDLE_PERIOD,
- IN_SHORT_IDLE_PERIOD,
- IN_LONG_IDLE_PERIOD,
- IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE,
- IN_LONG_IDLE_PERIOD_PAUSED,
+ kNotInIdlePeriod,
+ kInShortIdlePeriod,
+ kInLongIdlePeriod,
+ kInLongIdlePeriodWithMaxDeadline,
+ kInLongIdlePeriodPaused,
// Must be the last entry.
- IDLE_PERIOD_STATE_COUNT,
- FIRST_IDLE_PERIOD_STATE = NOT_IN_IDLE_PERIOD,
+ kIdlePeriodStateCount,
+ kFirstIdlePeriodState = kNotInIdlePeriod,
};
// The maximum length of an idle period.
diff --git a/third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc b/third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc
index 6f8b670..2cb90bb 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc
@@ -273,8 +273,8 @@
static void CheckAllTaskQueueIdToString() {
CallForEachEnumValue<IdleHelper::IdlePeriodState>(
- IdleHelper::IdlePeriodState::FIRST_IDLE_PERIOD_STATE,
- IdleHelper::IdlePeriodState::IDLE_PERIOD_STATE_COUNT,
+ IdleHelper::IdlePeriodState::kFirstIdlePeriodState,
+ IdleHelper::IdlePeriodState::kIdlePeriodStateCount,
&IdleHelper::IdlePeriodStateToString);
}
@@ -353,9 +353,8 @@
RunUntilIdle();
EXPECT_EQ(0, run_count);
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- expected_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), expected_deadline);
RunUntilIdle();
EXPECT_EQ(1, run_count);
EXPECT_EQ(expected_deadline, deadline_in_task);
@@ -373,7 +372,7 @@
EXPECT_EQ(0, run_count);
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
idle_helper_->EndIdlePeriod();
RunUntilIdle();
@@ -390,7 +389,7 @@
base::Bind(&RepostingIdleTestTask, base::RetainedRef(idle_task_runner_),
&run_count, &actual_deadline));
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
EXPECT_EQ(1, run_count);
@@ -400,7 +399,7 @@
EXPECT_EQ(1, run_count);
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
EXPECT_EQ(2, run_count);
@@ -418,7 +417,7 @@
base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(), &run_count));
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
// Only the first idle task should execute since it's used up the deadline.
@@ -426,7 +425,7 @@
idle_helper_->EndIdlePeriod();
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
// Second task should be run on the next idle period.
@@ -467,7 +466,7 @@
ExpectIdlePeriodStartsButNeverEnds();
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
}
@@ -483,7 +482,7 @@
ExpectIdlePeriodStartsAndEnds(Exactly(1));
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
idle_helper_->EndIdlePeriod();
}
@@ -506,7 +505,7 @@
}
}
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
base::RunLoop().RunUntilIdle();
}
@@ -547,7 +546,7 @@
base::Unretained(&tasks_to_post_from_nested_loop)));
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
// Note we expect task 3 to run last because it's non-nestable.
@@ -848,7 +847,7 @@
base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, idle_helper_.get(),
&can_exceed_idle_deadline, &run_count));
idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, clock_->NowTicks(),
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(10));
RunUntilIdle();
EXPECT_EQ(1, run_count);
@@ -1037,15 +1036,13 @@
base::TimeTicks more_than_min_deadline(
clock_->NowTicks() + minimum_idle_period_duration() + half_a_ms);
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- less_than_min_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), less_than_min_deadline);
RunUntilIdle();
EXPECT_EQ(0, run_count);
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- more_than_min_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), more_than_min_deadline);
RunUntilIdle();
EXPECT_EQ(1, run_count);
}
@@ -1125,17 +1122,15 @@
clock_->Advance(base::TimeDelta::FromMilliseconds(100));
// It shouldn't run until the delay is over even though we went idle.
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- expected_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), expected_deadline);
EXPECT_EQ(0u, idle_queue()->GetNumberOfPendingTasks());
RunUntilIdle();
EXPECT_EQ(0, run_count);
clock_->Advance(base::TimeDelta::FromMilliseconds(100));
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- expected_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), expected_deadline);
EXPECT_EQ(1u, idle_queue()->GetNumberOfPendingTasks());
RunUntilIdle();
@@ -1166,9 +1161,8 @@
RunUntilIdle();
EXPECT_EQ(0, run_count);
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- expected_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), expected_deadline);
RunUntilIdle();
EXPECT_EQ(1, run_count);
EXPECT_EQ(expected_deadline, deadline_in_task);
@@ -1200,9 +1194,8 @@
RunUntilIdle();
EXPECT_EQ(0, run_count);
- idle_helper_->StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, clock_->NowTicks(),
- expected_deadline);
+ idle_helper_->StartIdlePeriod(IdleHelper::IdlePeriodState::kInShortIdlePeriod,
+ clock_->NowTicks(), expected_deadline);
RunUntilIdle();
EXPECT_EQ(2, run_count);
EXPECT_EQ(expected_deadline, deadline_in_task);
diff --git a/third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.cc b/third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.cc
index fe5df991..beadc92 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/scheduler_helper.cc
@@ -24,7 +24,7 @@
void SchedulerHelper::InitDefaultQueues(
scoped_refptr<TaskQueue> default_task_queue,
scoped_refptr<TaskQueue> control_task_queue) {
- control_task_queue->SetQueuePriority(TaskQueue::CONTROL_PRIORITY);
+ control_task_queue->SetQueuePriority(TaskQueue::kControlPriority);
DCHECK(task_queue_manager_delegate_);
task_queue_manager_delegate_->SetDefaultTaskRunner(default_task_queue);
diff --git a/third_party/WebKit/Source/platform/scheduler/child/web_scheduler.h b/third_party/WebKit/Source/platform/scheduler/child/web_scheduler.h
index 2a6c394b..c5d987b 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/web_scheduler.h
+++ b/third_party/WebKit/Source/platform/scheduler/child/web_scheduler.h
@@ -74,7 +74,7 @@
// Returns a WebTaskRunner for timer tasks. Can be called from any thread.
virtual WebTaskRunner* TimerTaskRunner() = 0;
- // Returns a WebTaskRunner for V8 tasks. Can be called from any thread.
+ // Returns a WebTaskRunner for kV8 tasks. Can be called from any thread.
virtual WebTaskRunner* V8TaskRunner() = 0;
// Returns a WebTaskRunner for compositor tasks. This is intended only to be
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
index 0e22ef3..16d1e36 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/budget_pool_unittest.cc
@@ -133,7 +133,7 @@
task_queue_throttler_->CreateWakeUpBudgetPool("test");
scoped_refptr<TaskQueue> queue = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
pool->SetWakeUpRate(0.1);
pool->SetWakeUpDuration(base::TimeDelta::FromMilliseconds(10));
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_scheduler_helper.cc b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_scheduler_helper.cc
index f2151ff..7b70aeb4 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_scheduler_helper.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_scheduler_helper.cc
@@ -17,11 +17,11 @@
renderer_scheduler_(renderer_scheduler),
default_task_queue_(
NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::DEFAULT)
+ MainThreadTaskQueue::QueueType::kDefault)
.SetShouldMonitorQuiescence(true))),
control_task_queue_(
NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::CONTROL)
+ MainThreadTaskQueue::QueueType::kControl)
.SetShouldNotifyObservers(false))) {
InitDefaultQueues(default_task_queue_, control_task_queue_);
}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.cc b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.cc
index ad2d26af..d8a7474 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.cc
@@ -14,41 +14,41 @@
const char* MainThreadTaskQueue::NameForQueueType(
MainThreadTaskQueue::QueueType queue_type) {
switch (queue_type) {
- case MainThreadTaskQueue::QueueType::CONTROL:
+ case MainThreadTaskQueue::QueueType::kControl:
return "ControlTQ";
- case MainThreadTaskQueue::QueueType::DEFAULT:
+ case MainThreadTaskQueue::QueueType::kDefault:
return "DefaultTQ";
- case MainThreadTaskQueue::QueueType::DEFAULT_LOADING:
+ case MainThreadTaskQueue::QueueType::kDefaultLoading:
return "DefaultLoadingTQ";
- case MainThreadTaskQueue::QueueType::DEFAULT_TIMER:
+ case MainThreadTaskQueue::QueueType::kDefaultTimer:
return "DefaultTimerTQ";
- case MainThreadTaskQueue::QueueType::UNTHROTTLED:
+ case MainThreadTaskQueue::QueueType::kUnthrottled:
return "UnthrottledTQ";
- case MainThreadTaskQueue::QueueType::FRAME_LOADING:
+ case MainThreadTaskQueue::QueueType::kFrameLoading:
return "FrameLoadingTQ";
- case MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE:
+ case MainThreadTaskQueue::QueueType::kFrameThrottleable:
return "FrameThrottleableTQ";
- case MainThreadTaskQueue::QueueType::FRAME_DEFERRABLE:
+ case MainThreadTaskQueue::QueueType::kFrameDeferrable:
return "FrameDeferrableTQ";
- case MainThreadTaskQueue::QueueType::FRAME_PAUSABLE:
+ case MainThreadTaskQueue::QueueType::kFramePausable:
return "FramePausableTQ";
- case MainThreadTaskQueue::QueueType::FRAME_UNPAUSABLE:
+ case MainThreadTaskQueue::QueueType::kFrameUnpausable:
return "FrameUnpausableTQ";
- case MainThreadTaskQueue::QueueType::COMPOSITOR:
+ case MainThreadTaskQueue::QueueType::kCompositor:
return "CompositorTQ";
- case MainThreadTaskQueue::QueueType::IDLE:
+ case MainThreadTaskQueue::QueueType::kIdle:
return "IdleTQ";
- case MainThreadTaskQueue::QueueType::TEST:
+ case MainThreadTaskQueue::QueueType::kTest:
return "TestTQ";
- case MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL:
+ case MainThreadTaskQueue::QueueType::kFrameLoading_kControl:
return "FrameLoadingControlTQ";
- case MainThreadTaskQueue::QueueType::V8:
+ case MainThreadTaskQueue::QueueType::kV8:
return "V8TQ";
- case MainThreadTaskQueue::QueueType::IPC:
+ case MainThreadTaskQueue::QueueType::kIPC:
return "IPCTQ";
- case MainThreadTaskQueue::QueueType::OTHER:
+ case MainThreadTaskQueue::QueueType::kOther:
return "OtherTQ";
- case MainThreadTaskQueue::QueueType::COUNT:
+ case MainThreadTaskQueue::QueueType::kCount:
NOTREACHED();
return nullptr;
}
@@ -59,33 +59,33 @@
MainThreadTaskQueue::QueueClass MainThreadTaskQueue::QueueClassForQueueType(
QueueType type) {
switch (type) {
- case QueueType::CONTROL:
- case QueueType::DEFAULT:
- case QueueType::IDLE:
- case QueueType::TEST:
- case QueueType::V8:
- case QueueType::IPC:
- return QueueClass::NONE;
- case QueueType::DEFAULT_LOADING:
- case QueueType::FRAME_LOADING:
- case QueueType::FRAME_LOADING_CONTROL:
- return QueueClass::LOADING;
- case QueueType::DEFAULT_TIMER:
- case QueueType::UNTHROTTLED:
- case QueueType::FRAME_THROTTLEABLE:
- case QueueType::FRAME_DEFERRABLE:
- case QueueType::FRAME_PAUSABLE:
- case QueueType::FRAME_UNPAUSABLE:
- return QueueClass::TIMER;
- case QueueType::COMPOSITOR:
- return QueueClass::COMPOSITOR;
- case QueueType::OTHER:
- case QueueType::COUNT:
+ case QueueType::kControl:
+ case QueueType::kDefault:
+ case QueueType::kIdle:
+ case QueueType::kTest:
+ case QueueType::kV8:
+ case QueueType::kIPC:
+ return QueueClass::kNone;
+ case QueueType::kDefaultLoading:
+ case QueueType::kFrameLoading:
+ case QueueType::kFrameLoading_kControl:
+ return QueueClass::kLoading;
+ case QueueType::kDefaultTimer:
+ case QueueType::kUnthrottled:
+ case QueueType::kFrameThrottleable:
+ case QueueType::kFrameDeferrable:
+ case QueueType::kFramePausable:
+ case QueueType::kFrameUnpausable:
+ return QueueClass::kTimer;
+ case QueueType::kCompositor:
+ return QueueClass::kCompositor;
+ case QueueType::kOther:
+ case QueueType::kCount:
DCHECK(false);
- return QueueClass::COUNT;
+ return QueueClass::kCount;
}
NOTREACHED();
- return QueueClass::NONE;
+ return QueueClass::kNone;
}
MainThreadTaskQueue::MainThreadTaskQueue(
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.h b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.h
index 4377857..aaf4ecb 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/main_thread_task_queue.h
@@ -23,30 +23,30 @@
// This enum is used for a histogram and it should not be re-numbered.
// TODO(altimin): Clean up obsolete names and use a new histogram when
// the situation settles.
- CONTROL = 0,
- DEFAULT = 1,
- DEFAULT_LOADING = 2,
- // DEFAULT_TIMER is deprecated and should be replaced with appropriate
+ kControl = 0,
+ kDefault = 1,
+ kDefaultLoading = 2,
+ // kDefaultTimer is deprecated and should be replaced with appropriate
// per-frame task queues.
- DEFAULT_TIMER = 3,
- UNTHROTTLED = 4,
- FRAME_LOADING = 5,
- // 6 : FRAME_THROTTLEABLE, replaced with FRAME_THROTTLEABLE.
- // 7 : FRAME_PAUSABLE, replaced with FRAME_PAUSABLE
- COMPOSITOR = 8,
- IDLE = 9,
- TEST = 10,
- FRAME_LOADING_CONTROL = 11,
- FRAME_THROTTLEABLE = 12,
- FRAME_DEFERRABLE = 13,
- FRAME_PAUSABLE = 14,
- FRAME_UNPAUSABLE = 15,
- V8 = 16,
- IPC = 17,
+ kDefaultTimer = 3,
+ kUnthrottled = 4,
+ kFrameLoading = 5,
+ // 6 : kFrameThrottleable, replaced with FRAME_THROTTLEABLE.
+ // 7 : kFramePausable, replaced with kFramePausable
+ kCompositor = 8,
+ kIdle = 9,
+ kTest = 10,
+ kFrameLoading_kControl = 11,
+ kFrameThrottleable = 12,
+ kFrameDeferrable = 13,
+ kFramePausable = 14,
+ kFrameUnpausable = 15,
+ kV8 = 16,
+ kIPC = 17,
// Used to group multiple types when calculating Expected Queueing Time.
- OTHER = 18,
- COUNT = 19
+ kOther = 18,
+ kCount = 19
};
// Returns name of the given queue type. Returned string has application
@@ -55,12 +55,12 @@
// High-level category used by RendererScheduler to make scheduling decisions.
enum class QueueClass {
- NONE = 0,
- LOADING = 1,
- TIMER = 2,
- COMPOSITOR = 4,
+ kNone = 0,
+ kLoading = 1,
+ kTimer = 2,
+ kCompositor = 4,
- COUNT = 5
+ kCount = 5,
};
static QueueClass QueueClassForQueueType(QueueType type);
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.cc b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.cc
index 26b8b88..51dc4206 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.cc
@@ -103,35 +103,35 @@
const char* QueueingTimeEstimator::Calculator::GetReportingMessageFromQueueType(
MainThreadTaskQueue::QueueType queue_type) {
switch (queue_type) {
- case MainThreadTaskQueue::QueueType::DEFAULT:
+ case MainThreadTaskQueue::QueueType::kDefault:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Default";
- case MainThreadTaskQueue::QueueType::DEFAULT_LOADING:
+ case MainThreadTaskQueue::QueueType::kDefaultLoading:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType."
"DefaultLoading";
- case MainThreadTaskQueue::QueueType::UNTHROTTLED:
+ case MainThreadTaskQueue::QueueType::kUnthrottled:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType."
"Unthrottled";
- case MainThreadTaskQueue::QueueType::FRAME_LOADING:
+ case MainThreadTaskQueue::QueueType::kFrameLoading:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType."
"FrameLoading";
- case MainThreadTaskQueue::QueueType::COMPOSITOR:
+ case MainThreadTaskQueue::QueueType::kCompositor:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Compositor";
- case MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE:
+ case MainThreadTaskQueue::QueueType::kFrameThrottleable:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType."
"FrameThrottleable";
- case MainThreadTaskQueue::QueueType::FRAME_PAUSABLE:
+ case MainThreadTaskQueue::QueueType::kFramePausable:
return "RendererScheduler.ExpectedQueueingTimeByTaskQueueType."
"FramePausable";
- case MainThreadTaskQueue::QueueType::CONTROL:
- case MainThreadTaskQueue::QueueType::DEFAULT_TIMER:
- case MainThreadTaskQueue::QueueType::IDLE:
- case MainThreadTaskQueue::QueueType::TEST:
- case MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL:
- case MainThreadTaskQueue::QueueType::FRAME_DEFERRABLE:
- case MainThreadTaskQueue::QueueType::FRAME_UNPAUSABLE:
- case MainThreadTaskQueue::QueueType::V8:
- case MainThreadTaskQueue::QueueType::OTHER:
- case MainThreadTaskQueue::QueueType::COUNT:
+ case MainThreadTaskQueue::QueueType::kControl:
+ case MainThreadTaskQueue::QueueType::kDefaultTimer:
+ case MainThreadTaskQueue::QueueType::kIdle:
+ case MainThreadTaskQueue::QueueType::kTest:
+ case MainThreadTaskQueue::QueueType::kFrameLoading_kControl:
+ case MainThreadTaskQueue::QueueType::kFrameDeferrable:
+ case MainThreadTaskQueue::QueueType::kFrameUnpausable:
+ case MainThreadTaskQueue::QueueType::kV8:
+ case MainThreadTaskQueue::QueueType::kOther:
+ case MainThreadTaskQueue::QueueType::kCount:
// Using default here as well because there are some values less than COUNT
// that have been removed and do not correspond to any QueueType.
default:
@@ -143,49 +143,49 @@
const char* QueueingTimeEstimator::Calculator::GetReportingMessageFromFrameType(
FrameType frame_type) {
switch (frame_type) {
- case FrameType::MAIN_FRAME_VISIBLE:
- case FrameType::MAIN_FRAME_VISIBLE_SERVICE:
+ case FrameType::kMainFrameVisible:
+ case FrameType::kMainFrameVisibleService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"MainFrameVisible";
- case FrameType::MAIN_FRAME_HIDDEN:
- case FrameType::MAIN_FRAME_HIDDEN_SERVICE:
+ case FrameType::kMainFrameHidden:
+ case FrameType::kMainFrameHiddenService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"MainFrameHidden";
- case FrameType::MAIN_FRAME_BACKGROUND:
- case FrameType::MAIN_FRAME_BACKGROUND_EXEMPT_SELF:
- case FrameType::MAIN_FRAME_BACKGROUND_EXEMPT_OTHER:
+ case FrameType::kMainFrameBackground:
+ case FrameType::kMainFrameBackgroundExemptSelf:
+ case FrameType::kMainFrameBackgroundExemptOther:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"MainFrameBackground";
- case FrameType::SAME_ORIGIN_VISIBLE:
- case FrameType::SAME_ORIGIN_VISIBLE_SERVICE:
+ case FrameType::kSameOriginVisible:
+ case FrameType::kSameOriginVisibleService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"SameOriginVisible";
- case FrameType::SAME_ORIGIN_HIDDEN:
- case FrameType::SAME_ORIGIN_HIDDEN_SERVICE:
+ case FrameType::kSameOriginHidden:
+ case FrameType::kSameOriginHiddenService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"SameOriginHidden";
- case FrameType::SAME_ORIGIN_BACKGROUND:
- case FrameType::SAME_ORIGIN_BACKGROUND_EXEMPT_SELF:
- case FrameType::SAME_ORIGIN_BACKGROUND_EXEMPT_OTHER:
+ case FrameType::kSameOriginBackground:
+ case FrameType::kSameOriginBackgroundExemptSelf:
+ case FrameType::kSameOriginBackgroundExemptOther:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"SameOriginBackground";
- case FrameType::CROSS_ORIGIN_VISIBLE:
- case FrameType::CROSS_ORIGIN_VISIBLE_SERVICE:
+ case FrameType::kCrossOriginVisible:
+ case FrameType::kCrossOriginVisibleService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"CrossOriginVisible";
- case FrameType::CROSS_ORIGIN_HIDDEN:
- case FrameType::CROSS_ORIGIN_HIDDEN_SERVICE:
+ case FrameType::kCrossOriginHidden:
+ case FrameType::kCrossOriginHiddenService:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"CrossOriginHidden";
- case FrameType::CROSS_ORIGIN_BACKGROUND:
- case FrameType::CROSS_ORIGIN_BACKGROUND_EXEMPT_SELF:
- case FrameType::CROSS_ORIGIN_BACKGROUND_EXEMPT_OTHER:
+ case FrameType::kCrossOriginBackground:
+ case FrameType::kCrossOriginBackgroundExemptSelf:
+ case FrameType::kCrossOriginBackgroundExemptOther:
return "RendererScheduler.ExpectedQueueingTimeByFrameType."
"CrossOriginBackground";
- case FrameType::NONE:
- case FrameType::DETACHED:
+ case FrameType::kNone:
+ case FrameType::kDetached:
return "RendererScheduler.ExpectedQueueingTimeByFrameType.Other";
- case FrameType::COUNT:
+ case FrameType::kCount:
NOTREACHED();
return "";
}
@@ -196,9 +196,9 @@
void QueueingTimeEstimator::Calculator::UpdateStatusFromTaskQueue(
MainThreadTaskQueue* queue) {
current_queue_type_ =
- queue ? queue->queue_type() : MainThreadTaskQueue::QueueType::OTHER;
+ queue ? queue->queue_type() : MainThreadTaskQueue::QueueType::kOther;
WebFrameScheduler* scheduler = queue ? queue->GetFrameScheduler() : nullptr;
- current_frame_type_ = scheduler ? GetFrameType(scheduler) : FrameType::NONE;
+ current_frame_type_ = scheduler ? GetFrameType(scheduler) : FrameType::kNone;
}
void QueueingTimeEstimator::Calculator::AddQueueingTime(
@@ -225,13 +225,13 @@
return;
std::map<const char*, base::TimeDelta> delta_by_message;
- for (int i = 0; i < static_cast<int>(MainThreadTaskQueue::QueueType::COUNT);
+ for (int i = 0; i < static_cast<int>(MainThreadTaskQueue::QueueType::kCount);
++i) {
delta_by_message[GetReportingMessageFromQueueType(
static_cast<MainThreadTaskQueue::QueueType>(i))] +=
eqt_by_queue_type_[i];
}
- for (int i = 0; i < static_cast<int>(FrameType::COUNT); ++i) {
+ for (int i = 0; i < static_cast<int>(FrameType::kCount); ++i) {
delta_by_message[GetReportingMessageFromFrameType(
static_cast<FrameType>(i))] += eqt_by_frame_type_[i];
}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.h b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.h
index 87f0ce6..78889cb 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator.h
@@ -97,15 +97,15 @@
// Variables to split Expected Queueing Time by task queue type.
std::array<base::TimeDelta,
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT)>
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount)>
eqt_by_queue_type_;
MainThreadTaskQueue::QueueType current_queue_type_ =
- MainThreadTaskQueue::QueueType::OTHER;
+ MainThreadTaskQueue::QueueType::kOther;
// Variables to split Expected Queueing Time by frame type.
- std::array<base::TimeDelta, static_cast<int>(FrameType::COUNT)>
+ std::array<base::TimeDelta, static_cast<int>(FrameType::kCount)>
eqt_by_frame_type_;
- FrameType current_frame_type_ = FrameType::NONE;
+ FrameType current_frame_type_ = FrameType::kNone;
};
class State {
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator_unittest.cc
index 26e8e03..298873e 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/queueing_time_estimator_unittest.cc
@@ -741,7 +741,7 @@
// Beginning of window 1.
time += base::TimeDelta::FromMilliseconds(500);
scoped_refptr<MainThreadTaskQueueForTest> default_queue(
- new MainThreadTaskQueueForTest(QueueType::DEFAULT));
+ new MainThreadTaskQueueForTest(QueueType::kDefault));
estimator.OnTopLevelTaskStarted(time, default_queue.get());
time += base::TimeDelta::FromMilliseconds(3000);
estimator.OnTopLevelTaskCompleted(time);
@@ -749,7 +749,7 @@
time += base::TimeDelta::FromMilliseconds(1500);
// Beginning of window 2.
scoped_refptr<MainThreadTaskQueueForTest> default_loading_queue(
- new MainThreadTaskQueueForTest(QueueType::DEFAULT_LOADING));
+ new MainThreadTaskQueueForTest(QueueType::kDefaultLoading));
estimator.OnTopLevelTaskStarted(time, default_loading_queue.get());
time += base::TimeDelta::FromMilliseconds(2000);
estimator.OnTopLevelTaskCompleted(time);
@@ -771,11 +771,11 @@
time += base::TimeDelta::FromMilliseconds(1000);
scoped_refptr<MainThreadTaskQueueForTest> frame_loading_queue(
- new MainThreadTaskQueueForTest(QueueType::FRAME_LOADING));
+ new MainThreadTaskQueueForTest(QueueType::kFrameLoading));
scoped_refptr<MainThreadTaskQueueForTest> frame_throttleable_queue(
- new MainThreadTaskQueueForTest(QueueType::FRAME_THROTTLEABLE));
+ new MainThreadTaskQueueForTest(QueueType::kFrameThrottleable));
scoped_refptr<MainThreadTaskQueueForTest> unthrottled_queue(
- new MainThreadTaskQueueForTest(QueueType::UNTHROTTLED));
+ new MainThreadTaskQueueForTest(QueueType::kUnthrottled));
MainThreadTaskQueue* queues_for_thousand[] = {frame_loading_queue.get(),
frame_throttleable_queue.get(),
unthrottled_queue.get()};
@@ -787,9 +787,9 @@
// Beginning of window 5.
scoped_refptr<MainThreadTaskQueueForTest> frame_pausable_queue(
- new MainThreadTaskQueueForTest(QueueType::FRAME_PAUSABLE));
+ new MainThreadTaskQueueForTest(QueueType::kFramePausable));
scoped_refptr<MainThreadTaskQueueForTest> compositor_queue(
- new MainThreadTaskQueueForTest(QueueType::COMPOSITOR));
+ new MainThreadTaskQueueForTest(QueueType::kCompositor));
MainThreadTaskQueue* queues_for_six_hundred[] = {
default_queue.get(), default_loading_queue.get(),
frame_loading_queue.get(), frame_throttleable_queue.get(),
@@ -801,18 +801,18 @@
estimator.OnTopLevelTaskCompleted(time);
}
- // The following task contributes to "Other" because CONTROL is not a
+ // The following task contributes to "Other" because kControl is not a
// supported queue type.
scoped_refptr<MainThreadTaskQueueForTest> control_queue(
- new MainThreadTaskQueueForTest(QueueType::CONTROL));
+ new MainThreadTaskQueueForTest(QueueType::kControl));
estimator.OnTopLevelTaskStarted(time, control_queue.get());
time += base::TimeDelta::FromMilliseconds(300);
estimator.OnTopLevelTaskCompleted(time);
- // The following task contributes to "Other" because TEST is not a supported
+ // The following task contributes to "Other" because kTest is not a supported
// queue type.
scoped_refptr<MainThreadTaskQueueForTest> test_queue(
- new MainThreadTaskQueueForTest(QueueType::TEST));
+ new MainThreadTaskQueueForTest(QueueType::kTest));
estimator.OnTopLevelTaskStarted(time, test_queue.get());
time += base::TimeDelta::FromMilliseconds(300);
estimator.OnTopLevelTaskCompleted(time);
@@ -823,7 +823,7 @@
estimator.OnTopLevelTaskCompleted(time);
// End of window 5. Now check the vectors per task queue type.
- EXPECT_THAT(client.QueueTypeValues(QueueType::DEFAULT),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kDefault),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(900),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(800),
@@ -834,7 +834,7 @@
TestHistogram("RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Default",
5, expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::DEFAULT_LOADING),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kDefaultLoading),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(800),
base::TimeDelta::FromMilliseconds(900),
@@ -845,7 +845,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.DefaultLoading", 5,
expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::FRAME_LOADING),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kFrameLoading),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -856,7 +856,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.FrameLoading", 5,
expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::FRAME_THROTTLEABLE),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kFrameThrottleable),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -867,7 +867,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.FrameThrottleable",
5, expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::FRAME_PAUSABLE),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kFramePausable),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -878,7 +878,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.FramePausable", 5,
expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::UNTHROTTLED),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kUnthrottled),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -889,7 +889,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Unthrottled", 5,
expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::COMPOSITOR),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kCompositor),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -900,7 +900,7 @@
"RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Compositor", 5,
expected);
- EXPECT_THAT(client.QueueTypeValues(QueueType::OTHER),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kOther),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -916,7 +916,7 @@
base::TimeDelta::FromMilliseconds(1700),
base::TimeDelta::FromMilliseconds(400),
base::TimeDelta::FromMilliseconds(274)};
- EXPECT_THAT(client.FrameTypeValues(FrameType::NONE),
+ EXPECT_THAT(client.FrameTypeValues(FrameType::kNone),
::testing::ElementsAreArray(expected_sums));
expected = {{274, 1}, {400, 1}, {800, 1}, {900, 1}, {1700, 1}};
TestHistogram("RendererScheduler.ExpectedQueueingTimeByFrameType.Other", 5,
@@ -935,8 +935,8 @@
// the first 2000ms from a 3000ms task in a background main frame: 800 EQT for
// that.
// Window 4: The remaining 100 EQT for background main frame. Also 1000ms
-// tasks (which contribute 100) for SAME_ORIGIN_VISIBLE, SAME_ORIGIN_HIDDEN,
-// and CROSS_ORIGIN_VISIBLE.
+// tasks (which contribute 100) for kSameOriginVisible, kSameOriginHidden,
+// and kCrossOriginVisible.
// Window 5: 400 ms tasks (which contribute 16) for each of the buckets except
// other. Two 300 ms (each contributing 9) and one 800 ms tasks (contributes
// 64) for the other bucket.
@@ -948,7 +948,7 @@
estimator.OnTopLevelTaskStarted(time, nullptr);
estimator.OnTopLevelTaskCompleted(time);
scoped_refptr<MainThreadTaskQueueForTest> queue1(
- new MainThreadTaskQueueForTest(QueueType::TEST));
+ new MainThreadTaskQueueForTest(QueueType::kTest));
// Beginning of window 1.
time += base::TimeDelta::FromMilliseconds(500);
@@ -977,7 +977,7 @@
estimator.OnTopLevelTaskCompleted(time);
scoped_refptr<MainThreadTaskQueueForTest> queue2(
- new MainThreadTaskQueueForTest(QueueType::TEST));
+ new MainThreadTaskQueueForTest(QueueType::kTest));
queue2->SetFrameScheduler(frame2.get());
time += base::TimeDelta::FromMilliseconds(1000);
estimator.OnTopLevelTaskStarted(time, queue2.get());
@@ -1093,7 +1093,7 @@
estimator.OnTopLevelTaskCompleted(time);
// End of window 5. Now check the vectors per frame type.
- EXPECT_THAT(client.FrameTypeValues(FrameType::MAIN_FRAME_BACKGROUND),
+ EXPECT_THAT(client.FrameTypeValues(FrameType::kMainFrameBackground),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(900),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(800),
@@ -1105,7 +1105,7 @@
"RendererScheduler.ExpectedQueueingTimeByFrameType.MainFrameBackground",
5, expected);
- EXPECT_THAT(client.FrameTypeValues(FrameType::MAIN_FRAME_VISIBLE),
+ EXPECT_THAT(client.FrameTypeValues(FrameType::kMainFrameVisible),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(800),
base::TimeDelta::FromMilliseconds(900),
@@ -1121,11 +1121,11 @@
std::string name;
};
FrameExpectation three_expected[] = {
- {FrameType::SAME_ORIGIN_VISIBLE,
+ {FrameType::kSameOriginVisible,
"RendererScheduler.ExpectedQueueingTimeByFrameType.SameOriginVisible"},
- {FrameType::SAME_ORIGIN_HIDDEN,
+ {FrameType::kSameOriginHidden,
"RendererScheduler.ExpectedQueueingTimeByFrameType.SameOriginHidden"},
- {FrameType::CROSS_ORIGIN_VISIBLE,
+ {FrameType::kCrossOriginVisible,
"RendererScheduler.ExpectedQueueingTimeByFrameType.CrossOriginVisible"},
};
for (const auto& frame_expectation : three_expected) {
@@ -1140,15 +1140,15 @@
}
FrameExpectation more_expected[] = {
- {FrameType::MAIN_FRAME_HIDDEN,
+ {FrameType::kMainFrameHidden,
"RendererScheduler.ExpectedQueueingTimeByFrameType."
"MainFrameHidden"},
- {FrameType::SAME_ORIGIN_BACKGROUND,
+ {FrameType::kSameOriginBackground,
"RendererScheduler.ExpectedQueueingTimeByFrameType."
"SameOriginBackground"},
- {FrameType::CROSS_ORIGIN_HIDDEN,
+ {FrameType::kCrossOriginHidden,
"RendererScheduler.ExpectedQueueingTimeByFrameType.CrossOriginHidden"},
- {FrameType::CROSS_ORIGIN_BACKGROUND,
+ {FrameType::kCrossOriginBackground,
"RendererScheduler.ExpectedQueueingTimeByFrameType."
"CrossOriginBackground"}};
for (const auto& frame_expectation : more_expected) {
@@ -1162,7 +1162,7 @@
TestHistogram(frame_expectation.name, 5, expected);
}
- EXPECT_THAT(client.FrameTypeValues(FrameType::NONE),
+ EXPECT_THAT(client.FrameTypeValues(FrameType::kNone),
::testing::ElementsAre(base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
base::TimeDelta::FromMilliseconds(0),
@@ -1178,7 +1178,7 @@
base::TimeDelta::FromMilliseconds(1700),
base::TimeDelta::FromMilliseconds(400),
base::TimeDelta::FromMilliseconds(226)};
- EXPECT_THAT(client.QueueTypeValues(QueueType::OTHER),
+ EXPECT_THAT(client.QueueTypeValues(QueueType::kOther),
::testing::ElementsAreArray(expected_sums));
expected = {{226, 1}, {400, 1}, {800, 1}, {900, 1}, {1700, 1}};
TestHistogram("RendererScheduler.ExpectedQueueingTimeByTaskQueueType.Other",
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.cc
index 165eb42..89d2e4a7d 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.cc
@@ -22,7 +22,7 @@
MAIN_THREAD_LOAD_METRIC_NAME ".Extension"
#define PER_FRAME_TYPE_METRIC_NAME "RendererScheduler.TaskDurationPerFrameType2"
-enum class MainThreadTaskLoadState { LOW, HIGH, UNKNOWN };
+enum class MainThreadTaskLoadState { kLow, kHigh, kUnknown };
namespace {
@@ -37,72 +37,72 @@
base::TimeDelta::FromMinutes(3);
enum class FrameThrottlingState {
- VISIBLE = 0,
- VISIBLE_SERVICE = 1,
- HIDDEN = 2,
- HIDDEN_SERVICE = 3,
- BACKGROUND = 4,
- BACKGROUND_EXEMPT_SELF = 5,
- BACKGROUND_EXEMPT_OTHER = 6,
+ kVisible = 0,
+ kVisibleService = 1,
+ kHidden = 2,
+ kHiddenService = 3,
+ kBackground = 4,
+ kBackgroundExemptSelf = 5,
+ kBackgroundExemptOther = 6,
- COUNT = 7
+ kCount = 7
};
enum class FrameOriginState {
- MAIN_FRAME = 0,
- SAME_ORIGIN = 1,
- CROSS_ORIGIN = 2,
+ kMainFrame = 0,
+ kSameOrigin = 1,
+ kCrossOrigin = 2,
- COUNT = 3
+ kCount = 3
};
FrameThrottlingState GetFrameThrottlingState(
const WebFrameScheduler& frame_scheduler) {
if (frame_scheduler.IsPageVisible()) {
if (frame_scheduler.IsFrameVisible())
- return FrameThrottlingState::VISIBLE;
- return FrameThrottlingState::HIDDEN;
+ return FrameThrottlingState::kVisible;
+ return FrameThrottlingState::kHidden;
}
WebViewScheduler* web_view_scheduler = frame_scheduler.GetWebViewScheduler();
if (web_view_scheduler && web_view_scheduler->IsPlayingAudio()) {
if (frame_scheduler.IsFrameVisible())
- return FrameThrottlingState::VISIBLE_SERVICE;
- return FrameThrottlingState::HIDDEN_SERVICE;
+ return FrameThrottlingState::kVisibleService;
+ return FrameThrottlingState::kHiddenService;
}
if (frame_scheduler.IsExemptFromBudgetBasedThrottling())
- return FrameThrottlingState::BACKGROUND_EXEMPT_SELF;
+ return FrameThrottlingState::kBackgroundExemptSelf;
if (web_view_scheduler &&
web_view_scheduler->IsExemptFromBudgetBasedThrottling())
- return FrameThrottlingState::BACKGROUND_EXEMPT_OTHER;
+ return FrameThrottlingState::kBackgroundExemptOther;
- return FrameThrottlingState::BACKGROUND;
+ return FrameThrottlingState::kBackground;
}
FrameOriginState GetFrameOriginState(const WebFrameScheduler& frame_scheduler) {
if (frame_scheduler.GetFrameType() ==
WebFrameScheduler::FrameType::kMainFrame) {
- return FrameOriginState::MAIN_FRAME;
+ return FrameOriginState::kMainFrame;
}
if (frame_scheduler.IsCrossOrigin())
- return FrameOriginState::CROSS_ORIGIN;
- return FrameOriginState::SAME_ORIGIN;
+ return FrameOriginState::kCrossOrigin;
+ return FrameOriginState::kSameOrigin;
}
} // namespace
FrameType GetFrameType(WebFrameScheduler* frame_scheduler) {
if (!frame_scheduler)
- return FrameType::NONE;
+ return FrameType::kNone;
FrameThrottlingState throttling_state =
GetFrameThrottlingState(*frame_scheduler);
FrameOriginState origin_state = GetFrameOriginState(*frame_scheduler);
return static_cast<FrameType>(
- static_cast<int>(FrameType::SPECIAL_CASES_COUNT) +
+ static_cast<int>(FrameType::kSpecialCasesCount) +
static_cast<int>(origin_state) *
- static_cast<int>(FrameThrottlingState::COUNT) +
+ static_cast<int>(FrameThrottlingState::kCount) +
static_cast<int>(throttling_state));
}
@@ -156,7 +156,7 @@
hidden_music_task_duration_reporter(TASK_DURATION_METRIC_NAME
".HiddenMusic"),
frame_type_duration_reporter(PER_FRAME_TYPE_METRIC_NAME),
- main_thread_task_load_state(MainThreadTaskLoadState::UNKNOWN) {
+ main_thread_task_load_state(MainThreadTaskLoadState::kUnknown) {
main_thread_load_tracker.Resume(now);
if (renderer_backgrounded) {
background_main_thread_load_tracker.Resume(now);
@@ -228,36 +228,36 @@
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME, static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
if (duration >= base::TimeDelta::FromMilliseconds(16)) {
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME ".LongerThan16ms", static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
}
if (duration >= base::TimeDelta::FromMilliseconds(50)) {
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME ".LongerThan50ms", static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
}
if (duration >= base::TimeDelta::FromMilliseconds(100)) {
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME ".LongerThan100ms", static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
}
if (duration >= base::TimeDelta::FromMilliseconds(150)) {
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME ".LongerThan150ms", static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
}
if (duration >= base::TimeDelta::FromSeconds(1)) {
UMA_HISTOGRAM_ENUMERATION(
TASK_COUNT_METRIC_NAME ".LongerThan1s", static_cast<int>(queue_type),
- static_cast<int>(MainThreadTaskQueue::QueueType::COUNT));
+ static_cast<int>(MainThreadTaskQueue::QueueType::kCount));
}
task_duration_reporter.RecordTask(queue_type, duration);
@@ -366,13 +366,13 @@
// Avoid sending duplicate IPCs when the state doesn't change.
if (load_percentage <= main_thread_task_load_low_threshold &&
- main_thread_task_load_state != MainThreadTaskLoadState::LOW) {
+ main_thread_task_load_state != MainThreadTaskLoadState::kLow) {
RendererResourceCoordinator::Get().SetMainThreadTaskLoadIsLow(true);
- main_thread_task_load_state = MainThreadTaskLoadState::LOW;
+ main_thread_task_load_state = MainThreadTaskLoadState::kLow;
} else if (load_percentage > main_thread_task_load_low_threshold &&
- main_thread_task_load_state != MainThreadTaskLoadState::HIGH) {
+ main_thread_task_load_state != MainThreadTaskLoadState::kHigh) {
RendererResourceCoordinator::Get().SetMainThreadTaskLoadIsLow(false);
- main_thread_task_load_state = MainThreadTaskLoadState::HIGH;
+ main_thread_task_load_state = MainThreadTaskLoadState::kHigh;
}
}
@@ -454,7 +454,7 @@
void RendererMetricsHelper::RecordBackgroundedTransition(
BackgroundedRendererTransition transition) {
UMA_HISTOGRAM_ENUMERATION("RendererScheduler.BackgroundedRendererTransition",
- transition, BackgroundedRendererTransition::COUNT);
+ transition, BackgroundedRendererTransition::kCount);
}
} // namespace scheduler
} // namespace blink
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.h b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.h
index d46c6314..44447a7 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.h
@@ -29,7 +29,7 @@
// There are three main states:
// VISIBLE describes frames which are visible to the user (both page and frame
// are visible).
-// Without this service frame would have had BACKGROUNDED state.
+// Without this service frame would have had kBackgrounded state.
// HIDDEN describes frames which are out of viewport but the page is visible
// to the user.
// BACKGROUND describes frames in background pages.
@@ -42,66 +42,67 @@
// BACKGROUND_EXEMPT_SELF describes background frames which are
// exempted from background throttling due to a special conditions being met
// for this frame.
-// BACKGROUND_EXEMPT_OTHER describes background frames which are exempted from
+// BACKGROUND_EXEMPT_kOther describes background frames which are exempted from
// background throttling due to other frames granting an exemption for
// the whole page.
//
// Note that all these seven states are disjoint, e.g, when calculating
// a metric for background BACKGROUND, BACKGROUND_EXEMPT_SELF and
-// BACKGROUND_EXEMPT_OTHER should be added together.
+// BACKGROUND_EXEMPT_kOther should be added together.
enum class FrameType {
// Used to describe a task queue which doesn't have a frame associated
// (e.g. global task queue).
- NONE = 0,
+ kNone = 0,
// This frame was detached and does not have origin or visibility status
// anymore.
- DETACHED = 1,
+ kDetached = 1,
- SPECIAL_CASES_COUNT = 2,
+ kSpecialCasesCount = 2,
- MAIN_FRAME_VISIBLE = 2,
- MAIN_FRAME_VISIBLE_SERVICE = 3,
- MAIN_FRAME_HIDDEN = 4,
- MAIN_FRAME_HIDDEN_SERVICE = 5,
- MAIN_FRAME_BACKGROUND = 6,
- MAIN_FRAME_BACKGROUND_EXEMPT_SELF = 7,
- MAIN_FRAME_BACKGROUND_EXEMPT_OTHER = 8,
+ kMainFrameVisible = 2,
+ kMainFrameVisibleService = 3,
+ kMainFrameHidden = 4,
+ kMainFrameHiddenService = 5,
+ kMainFrameBackground = 6,
+ kMainFrameBackgroundExemptSelf = 7,
+ kMainFrameBackgroundExemptOther = 8,
- SAME_ORIGIN_VISIBLE = 9,
- SAME_ORIGIN_VISIBLE_SERVICE = 10,
- SAME_ORIGIN_HIDDEN = 11,
- SAME_ORIGIN_HIDDEN_SERVICE = 12,
- SAME_ORIGIN_BACKGROUND = 13,
- SAME_ORIGIN_BACKGROUND_EXEMPT_SELF = 14,
- SAME_ORIGIN_BACKGROUND_EXEMPT_OTHER = 15,
+ kSameOriginVisible = 9,
+ kSameOriginVisibleService = 10,
+ kSameOriginHidden = 11,
+ kSameOriginHiddenService = 12,
+ kSameOriginBackground = 13,
+ kSameOriginBackgroundExemptSelf = 14,
+ kSameOriginBackgroundExemptOther = 15,
- CROSS_ORIGIN_VISIBLE = 16,
- CROSS_ORIGIN_VISIBLE_SERVICE = 17,
- CROSS_ORIGIN_HIDDEN = 18,
- CROSS_ORIGIN_HIDDEN_SERVICE = 19,
- CROSS_ORIGIN_BACKGROUND = 20,
- CROSS_ORIGIN_BACKGROUND_EXEMPT_SELF = 21,
- CROSS_ORIGIN_BACKGROUND_EXEMPT_OTHER = 22,
+ kCrossOriginVisible = 16,
+ kCrossOriginVisibleService = 17,
+ kCrossOriginHidden = 18,
+ kCrossOriginHiddenService = 19,
+ kCrossOriginBackground = 20,
+ kCrossOriginBackgroundExemptSelf = 21,
+ kCrossOriginBackgroundExemptOther = 22,
- COUNT = 23
+ kCount = 23
};
// This enum is used for histogram and should not be renumbered.
// It tracks the following possible transitions:
-// -> BACKGROUNDED (-> [STOPPED_* -> RESUMED])? -> FOREGROUNDED
+// -> kBackgrounded (-> [STOPPED_* -> kResumed])? -> kForegrounded
enum class BackgroundedRendererTransition {
// Renderer is backgrounded
- BACKGROUNDED = 0,
+ kBackgrounded = 0,
// Renderer is stopped after being backgrounded for a while
- STOPPED_AFTER_DELAY = 1,
+ kStoppedAfterDelay = 1,
// Renderer is stopped due to critical resources, reserved for future use.
- STOPPED_DUE_TO_CRITICAL_RESOURCES = 2,
+ kStoppedDueToCriticalResources = 2,
// Renderer is resumed after being stopped
- RESUMED = 3,
+ kResumed = 3,
// Renderer is foregrounded
- FOREGROUNDED = 4,
- COUNT = 5
+ kForegrounded = 4,
+
+ kCount = 5
};
PLATFORM_EXPORT FrameType GetFrameType(WebFrameScheduler* frame_scheduler);
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper_unittest.cc
index 974d8d9c..75c01cb 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper_unittest.cc
@@ -78,71 +78,71 @@
};
TEST_F(RendererMetricsHelperTest, Metrics) {
- // QueueType::DEFAULT is checking sub-millisecond task aggregation,
+ // QueueType::kDefault is checking sub-millisecond task aggregation,
// FRAME_* tasks are checking normal task aggregation and other
// queue types have a single task.
- RunTask(QueueType::DEFAULT, Milliseconds(1),
+ RunTask(QueueType::kDefault, Milliseconds(1),
base::TimeDelta::FromMicroseconds(700));
- RunTask(QueueType::DEFAULT, Milliseconds(2),
+ RunTask(QueueType::kDefault, Milliseconds(2),
base::TimeDelta::FromMicroseconds(700));
- RunTask(QueueType::DEFAULT, Milliseconds(3),
+ RunTask(QueueType::kDefault, Milliseconds(3),
base::TimeDelta::FromMicroseconds(700));
- RunTask(QueueType::DEFAULT_LOADING, Milliseconds(200),
+ RunTask(QueueType::kDefaultLoading, Milliseconds(200),
base::TimeDelta::FromMilliseconds(20));
- RunTask(QueueType::CONTROL, Milliseconds(400),
+ RunTask(QueueType::kControl, Milliseconds(400),
base::TimeDelta::FromMilliseconds(30));
- RunTask(QueueType::DEFAULT_TIMER, Milliseconds(600),
+ RunTask(QueueType::kDefaultTimer, Milliseconds(600),
base::TimeDelta::FromMilliseconds(5));
- RunTask(QueueType::FRAME_LOADING, Milliseconds(800),
+ RunTask(QueueType::kFrameLoading, Milliseconds(800),
base::TimeDelta::FromMilliseconds(70));
- RunTask(QueueType::FRAME_PAUSABLE, Milliseconds(1000),
+ RunTask(QueueType::kFramePausable, Milliseconds(1000),
base::TimeDelta::FromMilliseconds(20));
- RunTask(QueueType::COMPOSITOR, Milliseconds(1200),
+ RunTask(QueueType::kCompositor, Milliseconds(1200),
base::TimeDelta::FromMilliseconds(25));
- RunTask(QueueType::TEST, Milliseconds(1600),
+ RunTask(QueueType::kTest, Milliseconds(1600),
base::TimeDelta::FromMilliseconds(85));
scheduler_->SetRendererBackgrounded(true);
- RunTask(QueueType::CONTROL, Milliseconds(2000),
+ RunTask(QueueType::kControl, Milliseconds(2000),
base::TimeDelta::FromMilliseconds(25));
- RunTask(QueueType::FRAME_THROTTLEABLE, Milliseconds(2600),
+ RunTask(QueueType::kFrameThrottleable, Milliseconds(2600),
base::TimeDelta::FromMilliseconds(175));
- RunTask(QueueType::UNTHROTTLED, Milliseconds(2800),
+ RunTask(QueueType::kUnthrottled, Milliseconds(2800),
base::TimeDelta::FromMilliseconds(25));
- RunTask(QueueType::FRAME_LOADING, Milliseconds(3000),
+ RunTask(QueueType::kFrameLoading, Milliseconds(3000),
base::TimeDelta::FromMilliseconds(35));
- RunTask(QueueType::FRAME_THROTTLEABLE, Milliseconds(3200),
+ RunTask(QueueType::kFrameThrottleable, Milliseconds(3200),
base::TimeDelta::FromMilliseconds(5));
- RunTask(QueueType::COMPOSITOR, Milliseconds(3400),
+ RunTask(QueueType::kCompositor, Milliseconds(3400),
base::TimeDelta::FromMilliseconds(20));
- RunTask(QueueType::IDLE, Milliseconds(3600),
+ RunTask(QueueType::kIdle, Milliseconds(3600),
base::TimeDelta::FromMilliseconds(50));
- RunTask(QueueType::FRAME_LOADING_CONTROL, Milliseconds(4000),
+ RunTask(QueueType::kFrameLoading_kControl, Milliseconds(4000),
base::TimeDelta::FromMilliseconds(5));
- RunTask(QueueType::CONTROL, Milliseconds(4200),
+ RunTask(QueueType::kControl, Milliseconds(4200),
base::TimeDelta::FromMilliseconds(20));
- RunTask(QueueType::FRAME_THROTTLEABLE, Milliseconds(4400),
+ RunTask(QueueType::kFrameThrottleable, Milliseconds(4400),
base::TimeDelta::FromMilliseconds(115));
- RunTask(QueueType::FRAME_PAUSABLE, Milliseconds(4600),
+ RunTask(QueueType::kFramePausable, Milliseconds(4600),
base::TimeDelta::FromMilliseconds(175));
- RunTask(QueueType::IDLE, Milliseconds(5000),
+ RunTask(QueueType::kIdle, Milliseconds(5000),
base::TimeDelta::FromMilliseconds(1600));
std::vector<base::Bucket> expected_samples = {
- {static_cast<int>(QueueType::CONTROL), 75},
- {static_cast<int>(QueueType::DEFAULT), 2},
- {static_cast<int>(QueueType::DEFAULT_LOADING), 20},
- {static_cast<int>(QueueType::DEFAULT_TIMER), 5},
- {static_cast<int>(QueueType::UNTHROTTLED), 25},
- {static_cast<int>(QueueType::FRAME_LOADING), 105},
- {static_cast<int>(QueueType::COMPOSITOR), 45},
- {static_cast<int>(QueueType::IDLE), 1650},
- {static_cast<int>(QueueType::TEST), 85},
- {static_cast<int>(QueueType::FRAME_LOADING_CONTROL), 5},
- {static_cast<int>(QueueType::FRAME_THROTTLEABLE), 295},
- {static_cast<int>(QueueType::FRAME_PAUSABLE), 195}};
+ {static_cast<int>(QueueType::kControl), 75},
+ {static_cast<int>(QueueType::kDefault), 2},
+ {static_cast<int>(QueueType::kDefaultLoading), 20},
+ {static_cast<int>(QueueType::kDefaultTimer), 5},
+ {static_cast<int>(QueueType::kUnthrottled), 25},
+ {static_cast<int>(QueueType::kFrameLoading), 105},
+ {static_cast<int>(QueueType::kCompositor), 45},
+ {static_cast<int>(QueueType::kIdle), 1650},
+ {static_cast<int>(QueueType::kTest), 85},
+ {static_cast<int>(QueueType::kFrameLoading_kControl), 5},
+ {static_cast<int>(QueueType::kFrameThrottleable), 295},
+ {static_cast<int>(QueueType::kFramePausable), 195}};
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.TaskDurationPerQueueType2"),
testing::ContainerEq(expected_samples));
@@ -150,31 +150,31 @@
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.TaskDurationPerQueueType2.Foreground"),
UnorderedElementsAre(
- Bucket(static_cast<int>(QueueType::CONTROL), 30),
- Bucket(static_cast<int>(QueueType::DEFAULT), 2),
- Bucket(static_cast<int>(QueueType::DEFAULT_LOADING), 20),
- Bucket(static_cast<int>(QueueType::DEFAULT_TIMER), 5),
- Bucket(static_cast<int>(QueueType::FRAME_LOADING), 70),
- Bucket(static_cast<int>(QueueType::COMPOSITOR), 25),
- Bucket(static_cast<int>(QueueType::TEST), 85),
- Bucket(static_cast<int>(QueueType::FRAME_PAUSABLE), 20)));
+ Bucket(static_cast<int>(QueueType::kControl), 30),
+ Bucket(static_cast<int>(QueueType::kDefault), 2),
+ Bucket(static_cast<int>(QueueType::kDefaultLoading), 20),
+ Bucket(static_cast<int>(QueueType::kDefaultTimer), 5),
+ Bucket(static_cast<int>(QueueType::kFrameLoading), 70),
+ Bucket(static_cast<int>(QueueType::kCompositor), 25),
+ Bucket(static_cast<int>(QueueType::kTest), 85),
+ Bucket(static_cast<int>(QueueType::kFramePausable), 20)));
EXPECT_THAT(
histogram_tester_->GetAllSamples(
"RendererScheduler.TaskDurationPerQueueType2.Background"),
UnorderedElementsAre(
- Bucket(static_cast<int>(QueueType::CONTROL), 45),
- Bucket(static_cast<int>(QueueType::UNTHROTTLED), 25),
- Bucket(static_cast<int>(QueueType::FRAME_LOADING), 35),
- Bucket(static_cast<int>(QueueType::FRAME_THROTTLEABLE), 295),
- Bucket(static_cast<int>(QueueType::FRAME_PAUSABLE), 175),
- Bucket(static_cast<int>(QueueType::COMPOSITOR), 20),
- Bucket(static_cast<int>(QueueType::IDLE), 1650),
- Bucket(static_cast<int>(QueueType::FRAME_LOADING_CONTROL), 5)));
+ Bucket(static_cast<int>(QueueType::kControl), 45),
+ Bucket(static_cast<int>(QueueType::kUnthrottled), 25),
+ Bucket(static_cast<int>(QueueType::kFrameLoading), 35),
+ Bucket(static_cast<int>(QueueType::kFrameThrottleable), 295),
+ Bucket(static_cast<int>(QueueType::kFramePausable), 175),
+ Bucket(static_cast<int>(QueueType::kCompositor), 20),
+ Bucket(static_cast<int>(QueueType::kIdle), 1650),
+ Bucket(static_cast<int>(QueueType::kFrameLoading_kControl), 5)));
}
TEST_F(RendererMetricsHelperTest, GetFrameTypeTest) {
- DCHECK_EQ(GetFrameType(nullptr), FrameType::NONE);
+ DCHECK_EQ(GetFrameType(nullptr), FrameType::kNone);
std::unique_ptr<FakeWebFrameScheduler> frame1 =
FakeWebFrameScheduler::Builder()
@@ -182,14 +182,14 @@
.SetIsPageVisible(true)
.SetIsFrameVisible(true)
.Build();
- EXPECT_EQ(GetFrameType(frame1.get()), FrameType::MAIN_FRAME_VISIBLE);
+ EXPECT_EQ(GetFrameType(frame1.get()), FrameType::kMainFrameVisible);
std::unique_ptr<FakeWebFrameScheduler> frame2 =
FakeWebFrameScheduler::Builder()
.SetFrameType(WebFrameScheduler::FrameType::kSubframe)
.SetIsPageVisible(true)
.Build();
- EXPECT_EQ(GetFrameType(frame2.get()), FrameType::SAME_ORIGIN_HIDDEN);
+ EXPECT_EQ(GetFrameType(frame2.get()), FrameType::kSameOriginHidden);
std::unique_ptr<FakeWebFrameScheduler> frame3 =
FakeWebFrameScheduler::Builder()
@@ -197,13 +197,13 @@
.SetIsPageVisible(true)
.SetIsCrossOrigin(true)
.Build();
- EXPECT_EQ(GetFrameType(frame3.get()), FrameType::CROSS_ORIGIN_HIDDEN);
+ EXPECT_EQ(GetFrameType(frame3.get()), FrameType::kCrossOriginHidden);
std::unique_ptr<FakeWebFrameScheduler> frame4 =
FakeWebFrameScheduler::Builder()
.SetFrameType(WebFrameScheduler::FrameType::kSubframe)
.Build();
- EXPECT_EQ(GetFrameType(frame4.get()), FrameType::SAME_ORIGIN_BACKGROUND);
+ EXPECT_EQ(GetFrameType(frame4.get()), FrameType::kSameOriginBackground);
std::unique_ptr<FakeWebFrameScheduler> frame5 =
FakeWebFrameScheduler::Builder()
@@ -211,7 +211,7 @@
.SetIsExemptFromThrottling(true)
.Build();
DCHECK_EQ(GetFrameType(frame5.get()),
- FrameType::MAIN_FRAME_BACKGROUND_EXEMPT_SELF);
+ FrameType::kMainFrameBackgroundExemptSelf);
std::unique_ptr<FakeWebViewScheduler> view1 =
FakeWebViewScheduler::Builder().SetIsPlayingAudio(true).Build();
@@ -222,7 +222,7 @@
.SetIsFrameVisible(true)
.SetFrameType(WebFrameScheduler::FrameType::kSubframe)
.Build();
- DCHECK_EQ(GetFrameType(frame6.get()), FrameType::SAME_ORIGIN_VISIBLE_SERVICE);
+ DCHECK_EQ(GetFrameType(frame6.get()), FrameType::kSameOriginVisibleService);
std::unique_ptr<FakeWebFrameScheduler> frame7 =
FakeWebFrameScheduler::Builder()
@@ -230,7 +230,7 @@
.SetIsCrossOrigin(true)
.SetFrameType(WebFrameScheduler::FrameType::kSubframe)
.Build();
- DCHECK_EQ(GetFrameType(frame7.get()), FrameType::CROSS_ORIGIN_HIDDEN_SERVICE);
+ DCHECK_EQ(GetFrameType(frame7.get()), FrameType::kCrossOriginHiddenService);
std::unique_ptr<FakeWebViewScheduler> view2 =
FakeWebViewScheduler::Builder().SetIsThrottlingExempt(true).Build();
@@ -241,7 +241,7 @@
.SetFrameType(WebFrameScheduler::FrameType::kMainFrame)
.Build();
DCHECK_EQ(GetFrameType(frame8.get()),
- FrameType::MAIN_FRAME_BACKGROUND_EXEMPT_OTHER);
+ FrameType::kMainFrameBackgroundExemptOther);
}
TEST_F(RendererMetricsHelperTest, BackgroundedRendererTransition) {
@@ -252,37 +252,36 @@
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.BackgroundedRendererTransition"),
UnorderedElementsAre(
- Bucket(static_cast<int>(Transition::BACKGROUNDED), 1)));
+ Bucket(static_cast<int>(Transition::kBackgrounded), 1)));
scheduler_->SetRendererBackgrounded(false);
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.BackgroundedRendererTransition"),
UnorderedElementsAre(
- Bucket(static_cast<int>(Transition::BACKGROUNDED), 1),
- Bucket(static_cast<int>(Transition::FOREGROUNDED), 1)));
+ Bucket(static_cast<int>(Transition::kBackgrounded), 1),
+ Bucket(static_cast<int>(Transition::kForegrounded), 1)));
scheduler_->SetRendererBackgrounded(true);
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.BackgroundedRendererTransition"),
UnorderedElementsAre(
- Bucket(static_cast<int>(Transition::BACKGROUNDED), 2),
- Bucket(static_cast<int>(Transition::FOREGROUNDED), 1)));
+ Bucket(static_cast<int>(Transition::kBackgrounded), 2),
+ Bucket(static_cast<int>(Transition::kForegrounded), 1)));
// Waste 5+ minutes so that the delayed stop is triggered
- RunTask(QueueType::DEFAULT, Milliseconds(1),
+ RunTask(QueueType::kDefault, Milliseconds(1),
base::TimeDelta::FromSeconds(5 * 61));
// Firing ForceUpdatePolicy multiple times to make sure that the metric is
// only recorded upon an actual change.
ForceUpdatePolicy();
ForceUpdatePolicy();
ForceUpdatePolicy();
- EXPECT_THAT(
- histogram_tester_->GetAllSamples(
- "RendererScheduler.BackgroundedRendererTransition"),
- UnorderedElementsAre(
- Bucket(static_cast<int>(Transition::BACKGROUNDED), 2),
- Bucket(static_cast<int>(Transition::FOREGROUNDED), 1),
- Bucket(static_cast<int>(Transition::STOPPED_AFTER_DELAY), 1)));
+ EXPECT_THAT(histogram_tester_->GetAllSamples(
+ "RendererScheduler.BackgroundedRendererTransition"),
+ UnorderedElementsAre(
+ Bucket(static_cast<int>(Transition::kBackgrounded), 2),
+ Bucket(static_cast<int>(Transition::kForegrounded), 1),
+ Bucket(static_cast<int>(Transition::kStoppedAfterDelay), 1)));
scheduler_->SetRendererBackgrounded(false);
ForceUpdatePolicy();
@@ -290,10 +289,10 @@
EXPECT_THAT(histogram_tester_->GetAllSamples(
"RendererScheduler.BackgroundedRendererTransition"),
UnorderedElementsAre(
- Bucket(static_cast<int>(Transition::BACKGROUNDED), 2),
- Bucket(static_cast<int>(Transition::FOREGROUNDED), 2),
- Bucket(static_cast<int>(Transition::STOPPED_AFTER_DELAY), 1),
- Bucket(static_cast<int>(Transition::RESUMED), 1)));
+ Bucket(static_cast<int>(Transition::kBackgrounded), 2),
+ Bucket(static_cast<int>(Transition::kForegrounded), 2),
+ Bucket(static_cast<int>(Transition::kStoppedAfterDelay), 1),
+ Bucket(static_cast<int>(Transition::kResumed), 1)));
}
// TODO(crbug.com/754656): Add tests for NthMinute and AfterNthMinute
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
index ed2a291..dce4cee 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
@@ -90,14 +90,14 @@
"RendererSchedulerIdlePeriod",
base::TimeDelta(),
helper_.NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::IDLE))),
+ MainThreadTaskQueue::QueueType::kIdle))),
idle_canceled_delayed_task_sweeper_(&helper_,
idle_helper_.IdleTaskRunner()),
render_widget_scheduler_signals_(this),
control_task_queue_(helper_.ControlMainThreadTaskQueue()),
compositor_task_queue_(
helper_.NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::COMPOSITOR)
+ MainThreadTaskQueue::QueueType::kCompositor)
.SetShouldMonitorQuiescence(true))),
compositor_task_queue_enabled_voter_(
compositor_task_queue_->CreateQueueEnabledVoter()),
@@ -128,13 +128,13 @@
compositor_task_queue_->CreateQueueEnabledVoter()));
default_loading_task_queue_ =
- NewLoadingTaskQueue(MainThreadTaskQueue::QueueType::DEFAULT_LOADING);
+ NewLoadingTaskQueue(MainThreadTaskQueue::QueueType::kDefaultLoading);
default_timer_task_queue_ =
- NewTimerTaskQueue(MainThreadTaskQueue::QueueType::DEFAULT_TIMER);
+ NewTimerTaskQueue(MainThreadTaskQueue::QueueType::kDefaultTimer);
v8_task_queue_ = NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::V8));
+ MainThreadTaskQueue::QueueType::kV8));
ipc_task_queue_ = NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::IPC));
+ MainThreadTaskQueue::QueueType::kIPC));
TRACE_EVENT_OBJECT_CREATED_WITH_ID(
TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
@@ -169,10 +169,10 @@
for (auto& pair : task_runners_) {
TaskCostEstimator* observer = nullptr;
switch (pair.first->queue_class()) {
- case MainThreadTaskQueue::QueueClass::LOADING:
+ case MainThreadTaskQueue::QueueClass::kLoading:
observer = &main_thread_only().loading_task_cost_estimator;
break;
- case MainThreadTaskQueue::QueueClass::TIMER:
+ case MainThreadTaskQueue::QueueClass::kTimer:
observer = &main_thread_only().timer_task_cost_estimator;
break;
default:
@@ -210,13 +210,13 @@
time_source,
kShortIdlePeriodDurationSampleCount,
kShortIdlePeriodDurationPercentile),
- current_use_case(UseCase::NONE,
+ current_use_case(UseCase::kNone,
"RendererScheduler.UseCase",
renderer_scheduler_impl,
UseCaseToString),
renderer_pause_count(0),
navigation_task_expected_count(0),
- expensive_task_policy(ExpensiveTaskPolicy::RUN),
+ expensive_task_policy(ExpensiveTaskPolicy::kRun),
renderer_hidden(false),
renderer_backgrounded(false,
"RendererScheduler.Backgrounded",
@@ -257,7 +257,7 @@
wake_up_budget_pool(nullptr),
metrics_helper(renderer_scheduler_impl, now, renderer_backgrounded),
process_type(RendererProcessType::kRenderer),
- virtual_time_policy(VirtualTimePolicy::ADVANCE),
+ virtual_time_policy(VirtualTimePolicy::kAdvance),
virtual_time_pause_count(0),
max_virtual_time_task_starvation_count(0),
virtual_time_stopped(false),
@@ -355,7 +355,7 @@
return default_timer_task_queue_;
}
-scoped_refptr<MainThreadTaskQueue> RendererSchedulerImpl::V8TaskQueue() {
+scoped_refptr<MainThreadTaskQueue> RendererSchedulerImpl::kV8TaskQueue() {
helper_.CheckOnValidThread();
return v8_task_queue_;
}
@@ -383,9 +383,9 @@
auto insert_result =
task_runners_.insert(std::make_pair(task_queue, std::move(voter)));
auto queue_class = task_queue->queue_class();
- if (queue_class == MainThreadTaskQueue::QueueClass::TIMER) {
+ if (queue_class == MainThreadTaskQueue::QueueClass::kTimer) {
task_queue->AddTaskObserver(&main_thread_only().timer_task_cost_estimator);
- } else if (queue_class == MainThreadTaskQueue::QueueClass::LOADING) {
+ } else if (queue_class == MainThreadTaskQueue::QueueClass::kLoading) {
task_queue->AddTaskObserver(
&main_thread_only().loading_task_cost_estimator);
}
@@ -397,9 +397,9 @@
if (task_queue->CanBeThrottled())
AddQueueToWakeUpBudgetPool(task_queue.get());
- if (queue_class == MainThreadTaskQueue::QueueClass::TIMER) {
+ if (queue_class == MainThreadTaskQueue::QueueClass::kTimer) {
if (main_thread_only().virtual_time_stopped)
- task_queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ task_queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
}
return task_queue;
@@ -408,7 +408,7 @@
scoped_refptr<MainThreadTaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue(
MainThreadTaskQueue::QueueType queue_type) {
DCHECK_EQ(MainThreadTaskQueue::QueueClassForQueueType(queue_type),
- MainThreadTaskQueue::QueueClass::LOADING);
+ MainThreadTaskQueue::QueueClass::kLoading);
return NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(queue_type)
.SetCanBePaused(true)
@@ -416,13 +416,13 @@
.SetCanBeDeferred(true)
.SetUsedForControlTasks(
queue_type ==
- MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL));
+ MainThreadTaskQueue::QueueType::kFrameLoading_kControl));
}
scoped_refptr<MainThreadTaskQueue> RendererSchedulerImpl::NewTimerTaskQueue(
MainThreadTaskQueue::QueueType queue_type) {
DCHECK_EQ(MainThreadTaskQueue::QueueClassForQueueType(queue_type),
- MainThreadTaskQueue::QueueClass::TIMER);
+ MainThreadTaskQueue::QueueClass::kTimer);
return NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(queue_type)
.SetShouldReportWhenExecutionBlocked(true)
.SetCanBePaused(true)
@@ -446,10 +446,10 @@
if (task_runners_.erase(task_queue)) {
switch (task_queue->queue_class()) {
- case MainThreadTaskQueue::QueueClass::TIMER:
+ case MainThreadTaskQueue::QueueClass::kTimer:
task_queue->RemoveTaskObserver(
&main_thread_only().timer_task_cost_estimator);
- case MainThreadTaskQueue::QueueClass::LOADING:
+ case MainThreadTaskQueue::QueueClass::kLoading:
task_queue->RemoveTaskObserver(
&main_thread_only().loading_task_cost_estimator);
default:
@@ -503,7 +503,7 @@
// TODO(rmcilroy): Consider reducing the idle period based on the runtime of
// the next pending delayed tasks (as currently done in for long idle times)
idle_helper_.StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, now,
main_thread_only().estimated_next_frame_begin);
}
@@ -543,7 +543,7 @@
// TODO(rmcilroy): Consider reducing the idle period based on the runtime of
// the next pending delayed tasks (as currently done in for long idle times)
idle_helper_.StartIdlePeriod(
- IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now, time);
+ IdleHelper::IdlePeriodState::kInShortIdlePeriod, now, time);
}
}
@@ -590,7 +590,7 @@
has_visible_render_widget_with_touch_handler;
base::AutoLock lock(any_thread_lock_);
- UpdatePolicyLocked(UpdateType::FORCE_UPDATE);
+ UpdatePolicyLocked(UpdateType::kForceUpdate);
}
void RendererSchedulerImpl::SetRendererHidden(bool hidden) {
@@ -614,12 +614,12 @@
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
"RendererSchedulerImpl::OnRendererBackgrounded");
RendererMetricsHelper::RecordBackgroundedTransition(
- BackgroundedRendererTransition::BACKGROUNDED);
+ BackgroundedRendererTransition::kBackgrounded);
} else {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
"RendererSchedulerImpl::OnRendererForegrounded");
RendererMetricsHelper::RecordBackgroundedTransition(
- BackgroundedRendererTransition::FOREGROUNDED);
+ BackgroundedRendererTransition::kForegrounded);
}
main_thread_only().renderer_backgrounded = backgrounded;
@@ -891,7 +891,7 @@
result == WebInputEventResult::kHandledApplication) {
any_thread().awaiting_touch_start_response = false;
any_thread().default_gesture_prevented = true;
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
}
}
}
@@ -910,10 +910,10 @@
// indicate a strong likelihood of high-priority work in the near future.
UseCase use_case = main_thread_only().current_use_case;
return main_thread_only().touchstart_expected_soon ||
- use_case == UseCase::TOUCHSTART ||
- use_case == UseCase::MAIN_THREAD_GESTURE ||
- use_case == UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING ||
- use_case == UseCase::SYNCHRONIZED_GESTURE;
+ use_case == UseCase::kTouchstart ||
+ use_case == UseCase::kMainThreadGesture ||
+ use_case == UseCase::kMainThreadCustomInputHandling ||
+ use_case == UseCase::kSynchronizedGesture;
}
bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
@@ -928,20 +928,20 @@
// for it since these tasks are not user-provided work and they are only
// intended to run before the next task, not interrupt the tasks.
switch (main_thread_only().current_use_case) {
- case UseCase::COMPOSITOR_GESTURE:
- case UseCase::NONE:
+ case UseCase::kCompositorGesture:
+ case UseCase::kNone:
return main_thread_only().touchstart_expected_soon;
- case UseCase::MAIN_THREAD_GESTURE:
- case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
- case UseCase::SYNCHRONIZED_GESTURE:
+ case UseCase::kMainThreadGesture:
+ case UseCase::kMainThreadCustomInputHandling:
+ case UseCase::kSynchronizedGesture:
return compositor_task_queue_->HasTaskToRunImmediately() ||
main_thread_only().touchstart_expected_soon;
- case UseCase::TOUCHSTART:
+ case UseCase::kTouchstart:
return true;
- case UseCase::LOADING:
+ case UseCase::kLoading:
return false;
default:
@@ -984,12 +984,12 @@
void RendererSchedulerImpl::UpdatePolicy() {
base::AutoLock lock(any_thread_lock_);
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
}
void RendererSchedulerImpl::ForceUpdatePolicy() {
base::AutoLock lock(any_thread_lock_);
- UpdatePolicyLocked(UpdateType::FORCE_UPDATE);
+ UpdatePolicyLocked(UpdateType::kForceUpdate);
}
namespace {
@@ -1106,81 +1106,81 @@
kFastCompositingIdleTimeThreshold;
Policy new_policy;
- ExpensiveTaskPolicy expensive_task_policy = ExpensiveTaskPolicy::RUN;
+ ExpensiveTaskPolicy expensive_task_policy = ExpensiveTaskPolicy::kRun;
new_policy.rail_mode() = v8::PERFORMANCE_ANIMATION;
switch (use_case) {
- case UseCase::COMPOSITOR_GESTURE:
+ case UseCase::kCompositorGesture:
if (touchstart_expected_soon) {
new_policy.rail_mode() = v8::PERFORMANCE_RESPONSE;
- expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+ expensive_task_policy = ExpensiveTaskPolicy::kBlock;
new_policy.compositor_queue_policy().priority =
- TaskQueue::HIGH_PRIORITY;
+ TaskQueue::kHighPriority;
} else {
// What we really want to do is priorize loading tasks, but that doesn't
// seem to be safe. Instead we do that by proxy by deprioritizing
// compositor tasks. This should be safe since we've already gone to the
// pain of fixing ordering issues with them.
- new_policy.compositor_queue_policy().priority = TaskQueue::LOW_PRIORITY;
+ new_policy.compositor_queue_policy().priority = TaskQueue::kLowPriority;
}
break;
- case UseCase::SYNCHRONIZED_GESTURE:
+ case UseCase::kSynchronizedGesture:
new_policy.compositor_queue_policy().priority =
- main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
- : TaskQueue::NORMAL_PRIORITY;
+ main_thread_compositing_is_fast ? TaskQueue::kHighPriority
+ : TaskQueue::kNormalPriority;
if (touchstart_expected_soon) {
new_policy.rail_mode() = v8::PERFORMANCE_RESPONSE;
- expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+ expensive_task_policy = ExpensiveTaskPolicy::kBlock;
} else {
- expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
+ expensive_task_policy = ExpensiveTaskPolicy::kThrottle;
}
break;
- case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
+ case UseCase::kMainThreadCustomInputHandling:
// In main thread input handling scenarios we don't have perfect knowledge
// about which things we should be prioritizing, so we don't attempt to
// block expensive tasks because we don't know whether they were integral
// to the page's functionality or not.
new_policy.compositor_queue_policy().priority =
- main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
- : TaskQueue::NORMAL_PRIORITY;
+ main_thread_compositing_is_fast ? TaskQueue::kHighPriority
+ : TaskQueue::kNormalPriority;
break;
- case UseCase::MAIN_THREAD_GESTURE:
+ case UseCase::kMainThreadGesture:
// A main thread gesture is for example a scroll gesture which is handled
// by the main thread. Since we know the established gesture type, we can
// be a little more aggressive about prioritizing compositing and input
// handling over other tasks.
- new_policy.compositor_queue_policy().priority = TaskQueue::HIGH_PRIORITY;
+ new_policy.compositor_queue_policy().priority = TaskQueue::kHighPriority;
if (touchstart_expected_soon) {
new_policy.rail_mode() = v8::PERFORMANCE_RESPONSE;
- expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+ expensive_task_policy = ExpensiveTaskPolicy::kBlock;
} else {
- expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
+ expensive_task_policy = ExpensiveTaskPolicy::kThrottle;
}
break;
- case UseCase::TOUCHSTART:
+ case UseCase::kTouchstart:
new_policy.rail_mode() = v8::PERFORMANCE_RESPONSE;
- new_policy.compositor_queue_policy().priority = TaskQueue::HIGH_PRIORITY;
+ new_policy.compositor_queue_policy().priority = TaskQueue::kHighPriority;
new_policy.loading_queue_policy().is_blocked = true;
new_policy.timer_queue_policy().is_blocked = true;
// NOTE this is a nop due to the above.
- expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+ expensive_task_policy = ExpensiveTaskPolicy::kBlock;
break;
- case UseCase::NONE:
+ case UseCase::kNone:
// It's only safe to block tasks that if we are expecting a compositor
// driven gesture.
if (touchstart_expected_soon &&
any_thread().last_gesture_was_compositor_driven) {
new_policy.rail_mode() = v8::PERFORMANCE_RESPONSE;
- expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+ expensive_task_policy = ExpensiveTaskPolicy::kBlock;
}
break;
- case UseCase::LOADING:
+ case UseCase::kLoading:
new_policy.rail_mode() = v8::PERFORMANCE_LOAD;
// TODO(skyostil): Experiment with increasing loading and default queue
// priorities and throttling rendering frame rate.
@@ -1194,24 +1194,24 @@
if (main_thread_only().renderer_hidden)
new_policy.rail_mode() = v8::PERFORMANCE_IDLE;
- if (expensive_task_policy == ExpensiveTaskPolicy::BLOCK &&
+ if (expensive_task_policy == ExpensiveTaskPolicy::kBlock &&
(!main_thread_only().have_seen_a_begin_main_frame ||
main_thread_only().navigation_task_expected_count > 0)) {
- expensive_task_policy = ExpensiveTaskPolicy::RUN;
+ expensive_task_policy = ExpensiveTaskPolicy::kRun;
}
switch (expensive_task_policy) {
- case ExpensiveTaskPolicy::RUN:
+ case ExpensiveTaskPolicy::kRun:
break;
- case ExpensiveTaskPolicy::BLOCK:
+ case ExpensiveTaskPolicy::kBlock:
if (loading_tasks_seem_expensive)
new_policy.loading_queue_policy().is_blocked = true;
if (timer_tasks_seem_expensive)
new_policy.timer_queue_policy().is_blocked = true;
break;
- case ExpensiveTaskPolicy::THROTTLE:
+ case ExpensiveTaskPolicy::kThrottle:
if (loading_tasks_seem_expensive) {
new_policy.loading_queue_policy().is_throttled = true;
}
@@ -1262,7 +1262,7 @@
"expensive_task_policy", expensive_task_policy);
// TODO(alexclarke): Can we get rid of force update now?
- if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
+ if (update_type == UpdateType::kMayEarlyOutIfPolicyUnchanged &&
new_policy == main_thread_only().current_policy) {
return;
}
@@ -1290,8 +1290,8 @@
SetStoppedInBackground(main_thread_only().stopped_when_backgrounded);
RendererMetricsHelper::RecordBackgroundedTransition(
main_thread_only().stopped_when_backgrounded
- ? BackgroundedRendererTransition::STOPPED_AFTER_DELAY
- : BackgroundedRendererTransition::RESUMED);
+ ? BackgroundedRendererTransition::kStoppedAfterDelay
+ : BackgroundedRendererTransition::kResumed);
}
}
@@ -1335,12 +1335,12 @@
new_task_queue_policy.GetTimeDomainType(task_queue);
if (old_time_domain_type != new_time_domain_type) {
- if (old_time_domain_type == TimeDomainType::THROTTLED) {
+ if (old_time_domain_type == TimeDomainType::kThrottled) {
task_queue_throttler_->DecreaseThrottleRefCount(task_queue);
- } else if (new_time_domain_type == TimeDomainType::THROTTLED) {
+ } else if (new_time_domain_type == TimeDomainType::kThrottled) {
task_queue_throttler_->IncreaseThrottleRefCount(task_queue);
}
- if (new_time_domain_type == TimeDomainType::VIRTUAL) {
+ if (new_time_domain_type == TimeDomainType::kVirtual) {
DCHECK(virtual_time_domain_);
task_queue->SetTimeDomain(virtual_time_domain_.get());
} else {
@@ -1359,7 +1359,7 @@
!any_thread().awaiting_touch_start_response) {
*expected_use_case_duration =
any_thread().fling_compositor_escalation_deadline - now;
- return UseCase::COMPOSITOR_GESTURE;
+ return UseCase::kCompositorGesture;
}
// Above all else we want to be responsive to user input.
*expected_use_case_duration =
@@ -1368,12 +1368,12 @@
// Has a gesture been fully established?
if (any_thread().awaiting_touch_start_response) {
// No, so arrange for compositor tasks to be run at the highest priority.
- return UseCase::TOUCHSTART;
+ return UseCase::kTouchstart;
}
// Yes a gesture has been established. Based on how the gesture is handled
// we need to choose between one of four use cases:
- // 1. COMPOSITOR_GESTURE where the gesture is processed only on the
+ // 1. kCompositorGesture where the gesture is processed only on the
// compositor thread.
// 2. MAIN_THREAD_GESTURE where the gesture is processed only on the main
// thread.
@@ -1383,15 +1383,15 @@
// 4. SYNCHRONIZED_GESTURE where the gesture is processed on both threads.
if (any_thread().last_gesture_was_compositor_driven) {
if (any_thread().begin_main_frame_on_critical_path) {
- return UseCase::SYNCHRONIZED_GESTURE;
+ return UseCase::kSynchronizedGesture;
} else {
- return UseCase::COMPOSITOR_GESTURE;
+ return UseCase::kCompositorGesture;
}
}
if (any_thread().default_gesture_prevented) {
- return UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING;
+ return UseCase::kMainThreadCustomInputHandling;
} else {
- return UseCase::MAIN_THREAD_GESTURE;
+ return UseCase::kMainThreadGesture;
}
}
@@ -1400,23 +1400,23 @@
// content on the page.
if (any_thread().waiting_for_meaningful_paint &&
!any_thread().have_seen_input_since_navigation) {
- return UseCase::LOADING;
+ return UseCase::kLoading;
}
- return UseCase::NONE;
+ return UseCase::kNone;
}
base::TimeDelta RendererSchedulerImpl::EstimateLongestJankFreeTaskDuration()
const {
switch (main_thread_only().current_use_case) {
- case UseCase::TOUCHSTART:
- case UseCase::COMPOSITOR_GESTURE:
- case UseCase::LOADING:
- case UseCase::NONE:
+ case UseCase::kTouchstart:
+ case UseCase::kCompositorGesture:
+ case UseCase::kLoading:
+ case UseCase::kNone:
return base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis);
- case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
- case UseCase::MAIN_THREAD_GESTURE:
- case UseCase::SYNCHRONIZED_GESTURE:
+ case UseCase::kMainThreadCustomInputHandling:
+ case UseCase::kMainThreadGesture:
+ case UseCase::kSynchronizedGesture:
return main_thread_only().idle_time_estimator.GetExpectedIdleDuration(
main_thread_only().compositor_frame_interval);
@@ -1432,7 +1432,7 @@
helper_.CheckOnValidThread();
MaybeUpdatePolicy();
- if (main_thread_only().current_use_case == UseCase::TOUCHSTART) {
+ if (main_thread_only().current_use_case == UseCase::kTouchstart) {
// Don't start a long idle task in touch start priority, try again when
// the policy is scheduled to end.
*next_long_idle_period_delay_out =
@@ -1487,9 +1487,9 @@
DCHECK(!virtual_time_control_task_queue_);
virtual_time_control_task_queue_ =
helper_.NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::CONTROL));
+ MainThreadTaskQueue::QueueType::kControl));
virtual_time_control_task_queue_->SetQueuePriority(
- TaskQueue::CONTROL_PRIORITY);
+ TaskQueue::kControlPriority);
virtual_time_control_task_queue_->SetTimeDomain(virtual_time_domain_.get());
main_thread_only().use_virtual_time = true;
@@ -1542,10 +1542,10 @@
void RendererSchedulerImpl::VirtualTimePaused() {
for (const auto& pair : task_runners_) {
- if (pair.first->queue_class() == MainThreadTaskQueue::QueueClass::TIMER) {
+ if (pair.first->queue_class() == MainThreadTaskQueue::QueueClass::kTimer) {
DCHECK(!task_queue_throttler_->IsThrottled(pair.first.get()));
DCHECK(!pair.first->HasActiveFence());
- pair.first->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ pair.first->InsertFence(TaskQueue::InsertFencePosition::kNow);
}
}
for (auto& observer : main_thread_only().virtual_time_observers) {
@@ -1556,7 +1556,7 @@
void RendererSchedulerImpl::VirtualTimeResumed() {
for (const auto& pair : task_runners_) {
- if (pair.first->queue_class() == MainThreadTaskQueue::QueueClass::TIMER) {
+ if (pair.first->queue_class() == MainThreadTaskQueue::QueueClass::kTimer) {
DCHECK(!task_queue_throttler_->IsThrottled(pair.first.get()));
DCHECK(pair.first->HasActiveFence());
pair.first->RemoveFence();
@@ -1583,15 +1583,15 @@
main_thread_only().virtual_time_policy = policy;
switch (policy) {
- case VirtualTimePolicy::ADVANCE:
+ case VirtualTimePolicy::kAdvance:
SetVirtualTimeStopped(false);
break;
- case VirtualTimePolicy::PAUSE:
+ case VirtualTimePolicy::kPause:
SetVirtualTimeStopped(true);
break;
- case VirtualTimePolicy::DETERMINISTIC_LOADING:
+ case VirtualTimePolicy::kDeterministicLoading:
ApplyVirtualTimePolicy();
break;
}
@@ -1618,7 +1618,7 @@
void RendererSchedulerImpl::ApplyVirtualTimePolicy() {
switch (main_thread_only().virtual_time_policy) {
- case VirtualTimePolicy::ADVANCE:
+ case VirtualTimePolicy::kAdvance:
if (virtual_time_domain_) {
virtual_time_domain_->SetMaxVirtualTimeTaskStarvationCount(
main_thread_only().nested_runloop
@@ -1627,12 +1627,12 @@
}
SetVirtualTimeStopped(false);
break;
- case VirtualTimePolicy::PAUSE:
+ case VirtualTimePolicy::kPause:
if (virtual_time_domain_)
virtual_time_domain_->SetMaxVirtualTimeTaskStarvationCount(0);
SetVirtualTimeStopped(true);
break;
- case VirtualTimePolicy::DETERMINISTIC_LOADING:
+ case VirtualTimePolicy::kDeterministicLoading:
if (virtual_time_domain_) {
virtual_time_domain_->SetMaxVirtualTimeTaskStarvationCount(
main_thread_only().nested_runloop
@@ -1686,11 +1686,11 @@
const char* RendererSchedulerImpl::ExpensiveTaskPolicyToString(
ExpensiveTaskPolicy expensive_task_policy) {
switch (expensive_task_policy) {
- case ExpensiveTaskPolicy::RUN:
+ case ExpensiveTaskPolicy::kRun:
return "RUN";
- case ExpensiveTaskPolicy::BLOCK:
+ case ExpensiveTaskPolicy::kBlock:
return "BLOCK";
- case ExpensiveTaskPolicy::THROTTLE:
+ case ExpensiveTaskPolicy::kThrottle:
return "THROTTLE";
default:
NOTREACHED();
@@ -1834,7 +1834,7 @@
TaskQueue::QueuePriority RendererSchedulerImpl::TaskQueuePolicy::GetPriority(
MainThreadTaskQueue* task_queue) const {
- return task_queue->UsedForControlTasks() ? TaskQueue::HIGH_PRIORITY
+ return task_queue->UsedForControlTasks() ? TaskQueue::kHighPriority
: priority;
}
@@ -1842,10 +1842,10 @@
RendererSchedulerImpl::TaskQueuePolicy::GetTimeDomainType(
MainThreadTaskQueue* task_queue) const {
if (use_virtual_time)
- return TimeDomainType::VIRTUAL;
+ return TimeDomainType::kVirtual;
if (is_throttled && task_queue->CanBeThrottled())
- return TimeDomainType::THROTTLED;
- return TimeDomainType::REAL;
+ return TimeDomainType::kThrottled;
+ return TimeDomainType::kReal;
}
void RendererSchedulerImpl::TaskQueuePolicy::AsValueInto(
@@ -1884,7 +1884,7 @@
void RendererSchedulerImpl::OnIdlePeriodStarted() {
base::AutoLock lock(any_thread_lock_);
any_thread().in_idle_period = true;
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
}
void RendererSchedulerImpl::OnIdlePeriodEnded() {
@@ -1892,7 +1892,7 @@
any_thread().last_idle_period_end_time =
helper_.scheduler_tqm_delegate()->NowTicks();
any_thread().in_idle_period = false;
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
}
void RendererSchedulerImpl::OnPendingTasksChanged(bool has_tasks) {
@@ -1973,7 +1973,7 @@
"RendererSchedulerImpl::OnFirstMeaningfulPaint");
base::AutoLock lock(any_thread_lock_);
any_thread().waiting_for_meaningful_paint = false;
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
}
void RendererSchedulerImpl::ResetForNavigationLocked() {
@@ -1995,7 +1995,7 @@
main_thread_only().web_view_schedulers) {
web_view_scheduler->OnNavigation();
}
- UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+ UpdatePolicyLocked(UpdateType::kMayEarlyOutIfPolicyUnchanged);
UMA_HISTOGRAM_COUNTS_100("RendererScheduler.WebViewsPerScheduler",
main_thread_only().web_view_schedulers.size());
@@ -2105,7 +2105,7 @@
}
void RendererSchedulerImpl::OnTriedToExecuteBlockedTask() {
- if (main_thread_only().current_use_case == UseCase::TOUCHSTART ||
+ if (main_thread_only().current_use_case == UseCase::kTouchstart ||
main_thread_only().longest_jank_free_task_duration <
base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis) ||
main_thread_only().renderer_pause_count ||
@@ -2289,19 +2289,19 @@
// static
const char* RendererSchedulerImpl::UseCaseToString(UseCase use_case) {
switch (use_case) {
- case UseCase::NONE:
+ case UseCase::kNone:
return "none";
- case UseCase::COMPOSITOR_GESTURE:
+ case UseCase::kCompositorGesture:
return "compositor_gesture";
- case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
+ case UseCase::kMainThreadCustomInputHandling:
return "main_thread_custom_input_handling";
- case UseCase::SYNCHRONIZED_GESTURE:
+ case UseCase::kSynchronizedGesture:
return "synchronized_gesture";
- case UseCase::TOUCHSTART:
+ case UseCase::kTouchstart:
return "touchstart";
- case UseCase::LOADING:
+ case UseCase::kLoading:
return "loading";
- case UseCase::MAIN_THREAD_GESTURE:
+ case UseCase::kMainThreadGesture:
return "main_thread_gesture";
default:
NOTREACHED();
@@ -2330,11 +2330,11 @@
const char* RendererSchedulerImpl::TimeDomainTypeToString(
TimeDomainType domain_type) {
switch (domain_type) {
- case TimeDomainType::REAL:
+ case TimeDomainType::kReal:
return "real";
- case TimeDomainType::THROTTLED:
+ case TimeDomainType::kThrottled:
return "throttled";
- case TimeDomainType::VIRTUAL:
+ case TimeDomainType::kVirtual:
return "virtual";
default:
NOTREACHED();
@@ -2346,11 +2346,11 @@
const char* RendererSchedulerImpl::VirtualTimePolicyToString(
VirtualTimePolicy virtual_time_policy) {
switch (virtual_time_policy) {
- case VirtualTimePolicy::ADVANCE:
+ case VirtualTimePolicy::kAdvance:
return "ADVANCE";
- case VirtualTimePolicy::PAUSE:
+ case VirtualTimePolicy::kPause:
return "PAUSE";
- case VirtualTimePolicy::DETERMINISTIC_LOADING:
+ case VirtualTimePolicy::kDeterministicLoading:
return "DETERMINISTIC_LOADING";
default:
NOTREACHED();
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h
index 411eaebf..c20e9289 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.h
@@ -63,31 +63,31 @@
// Keep RendererScheduler::UseCaseToString in sync with this enum.
enum class UseCase {
// No active use case detected.
- NONE,
+ kNone,
// A continuous gesture (e.g., scroll, pinch) which is being driven by the
// compositor thread.
- COMPOSITOR_GESTURE,
+ kCompositorGesture,
// An unspecified touch gesture which is being handled by the main thread.
// Note that since we don't have a full view of the use case, we should be
// careful to prioritize all work equally.
- MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ kMainThreadCustomInputHandling,
// A continuous gesture (e.g., scroll, pinch) which is being driven by the
// compositor thread but also observed by the main thread. An example is
// synchronized scrolling where a scroll listener on the main thread changes
// page layout based on the current scroll position.
- SYNCHRONIZED_GESTURE,
+ kSynchronizedGesture,
// A gesture has recently started and we are about to run main thread touch
// listeners to find out the actual gesture type. To minimize touch latency,
// only input handling work should run in this state.
- TOUCHSTART,
+ kTouchstart,
// A page is loading.
- LOADING,
+ kLoading,
// A continuous gesture (e.g., scroll) which is being handled by the main
// thread.
- MAIN_THREAD_GESTURE,
+ kMainThreadGesture,
// Must be the last entry.
- USE_CASE_COUNT,
- FIRST_USE_CASE = NONE,
+ kUseCaseCount,
+ kFirstUseCase = kNone,
};
static const char* UseCaseToString(UseCase use_case);
static const char* RAILModeToString(v8::RAILMode rail_mode);
@@ -163,7 +163,7 @@
scoped_refptr<MainThreadTaskQueue> CompositorTaskQueue();
scoped_refptr<MainThreadTaskQueue> LoadingTaskQueue();
scoped_refptr<MainThreadTaskQueue> TimerTaskQueue();
- scoped_refptr<MainThreadTaskQueue> V8TaskQueue();
+ scoped_refptr<MainThreadTaskQueue> kV8TaskQueue();
// Returns a new task queue created with given params.
scoped_refptr<MainThreadTaskQueue> NewTaskQueue(
@@ -171,7 +171,7 @@
// Returns a new loading task queue. This queue is intended for tasks related
// to resource dispatch, foreground HTML parsing, etc...
- // Note: Tasks posted to FRAME_LOADING_CONTROL queues must execute quickly.
+ // Note: Tasks posted to kFrameLoading_kControl queues must execute quickly.
scoped_refptr<MainThreadTaskQueue> NewLoadingTaskQueue(
MainThreadTaskQueue::QueueType queue_type);
@@ -292,12 +292,12 @@
renderer_scheduler_impl_unittest::RendererSchedulerImplTest,
Tracing);
- enum class ExpensiveTaskPolicy { RUN, BLOCK, THROTTLE };
+ enum class ExpensiveTaskPolicy { kRun, kBlock, kThrottle };
enum class TimeDomainType {
- REAL,
- THROTTLED,
- VIRTUAL,
+ kReal,
+ kThrottled,
+ kVirtual,
};
static const char* TimeDomainTypeToString(TimeDomainType domain_type);
@@ -314,7 +314,7 @@
is_blocked(false),
is_stopped(false),
use_virtual_time(false),
- priority(TaskQueue::NORMAL_PRIORITY) {}
+ priority(TaskQueue::kNormalPriority) {}
bool is_enabled;
bool is_paused;
@@ -350,38 +350,38 @@
TaskQueuePolicy& compositor_queue_policy() {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::COMPOSITOR)];
+ MainThreadTaskQueue::QueueClass::kCompositor)];
}
const TaskQueuePolicy& compositor_queue_policy() const {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::COMPOSITOR)];
+ MainThreadTaskQueue::QueueClass::kCompositor)];
}
TaskQueuePolicy& loading_queue_policy() {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::LOADING)];
+ MainThreadTaskQueue::QueueClass::kLoading)];
}
const TaskQueuePolicy& loading_queue_policy() const {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::LOADING)];
+ MainThreadTaskQueue::QueueClass::kLoading)];
}
TaskQueuePolicy& timer_queue_policy() {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::TIMER)];
+ MainThreadTaskQueue::QueueClass::kTimer)];
}
const TaskQueuePolicy& timer_queue_policy() const {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::TIMER)];
+ MainThreadTaskQueue::QueueClass::kTimer)];
}
TaskQueuePolicy& default_queue_policy() {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::NONE)];
+ MainThreadTaskQueue::QueueClass::kNone)];
}
const TaskQueuePolicy& default_queue_policy() const {
return policies_[static_cast<size_t>(
- MainThreadTaskQueue::QueueClass::NONE)];
+ MainThreadTaskQueue::QueueClass::kNone)];
}
const TaskQueuePolicy& GetQueuePolicy(
@@ -409,7 +409,7 @@
bool should_disable_throttling_;
std::array<TaskQueuePolicy,
- static_cast<size_t>(MainThreadTaskQueue::QueueClass::COUNT)>
+ static_cast<size_t>(MainThreadTaskQueue::QueueClass::kCount)>
policies_;
};
@@ -498,12 +498,12 @@
void ForceUpdatePolicy();
enum class UpdateType {
- MAY_EARLY_OUT_IF_POLICY_UNCHANGED,
- FORCE_UPDATE,
+ kMayEarlyOutIfPolicyUnchanged,
+ kForceUpdate,
};
// The implelemtation of UpdatePolicy & ForceUpdatePolicy. It is allowed to
- // early out if |update_type| is MAY_EARLY_OUT_IF_POLICY_UNCHANGED.
+ // early out if |update_type| is kMayEarlyOutIfPolicyUnchanged.
virtual void UpdatePolicyLocked(UpdateType update_type);
// Helper for computing the use case. |expected_usecase_duration| will be
@@ -657,12 +657,12 @@
base::TimeTicks initial_virtual_time;
VirtualTimePolicy virtual_time_policy;
- // In VirtualTimePolicy::DETERMINISTIC_LOADING virtual time is only allowed
+ // In VirtualTimePolicy::kDeterministicLoading virtual time is only allowed
// to advance if this is zero.
int virtual_time_pause_count;
// The maximum number amount of delayed task starvation we will allow in
- // VirtualTimePolicy::ADVANCE or VirtualTimePolicy::DETERMINISTIC_LOADING
+ // VirtualTimePolicy::kAdvance or VirtualTimePolicy::kDeterministicLoading
// unless the run_loop is nested (in which case infinite starvation is
// allowed). NB a value of 0 allows infinite starvation.
int max_virtual_time_task_starvation_count;
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
index 212cada..8c0444b 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
@@ -298,12 +298,12 @@
compositor_task_runner_ = scheduler_->CompositorTaskQueue();
loading_task_runner_ = scheduler_->LoadingTaskQueue();
loading_control_task_runner_ = scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL);
+ MainThreadTaskQueue::QueueType::kFrameLoading_kControl);
idle_task_runner_ = scheduler_->IdleTaskRunner();
timer_task_runner_ = scheduler_->TimerTaskQueue();
- v8_task_runner_ = scheduler_->V8TaskQueue();
+ v8_task_runner_ = scheduler_->kV8TaskQueue();
fake_queue_ = scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING);
+ MainThreadTaskQueue::QueueType::kFrameLoading);
}
void TearDown() override {
@@ -377,12 +377,12 @@
}
enum class TouchEventPolicy {
- SEND_TOUCH_START,
- DONT_SEND_TOUCH_START,
+ kSendTouchStart,
+ kDontSendTouchStart,
};
void SimulateCompositorGestureStart(TouchEventPolicy touch_event_policy) {
- if (touch_event_policy == TouchEventPolicy::SEND_TOUCH_START) {
+ if (touch_event_policy == TouchEventPolicy::kSendTouchStart) {
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kTouchStart),
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
@@ -431,7 +431,7 @@
// Touchstart policy update.
EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
- EXPECT_EQ(UseCase::TOUCHSTART, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kTouchstart, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
scheduler_->DidHandleInputEventOnCompositorThread(
@@ -446,7 +446,7 @@
// Main thread gesture policy update.
EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
@@ -462,14 +462,14 @@
// Compositor thread gesture policy update.
EXPECT_TRUE(scheduler_->PolicyNeedsUpdateForTesting());
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_FALSE(scheduler_->PolicyNeedsUpdateForTesting());
}
void SimulateMainThreadGestureStart(TouchEventPolicy touch_event_policy,
blink::WebInputEvent::Type gesture_type) {
- if (touch_event_policy == TouchEventPolicy::SEND_TOUCH_START) {
+ if (touch_event_policy == TouchEventPolicy::kSendTouchStart) {
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kTouchStart),
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
@@ -607,7 +607,7 @@
// - 'M': Loading Control task
// - 'I': Idle task
// - 'T': Timer task
- // - 'V': V8 task
+ // - 'V': kV8 task
void PostTestTasks(std::vector<std::string>* run_order,
const std::string& task_descriptor) {
std::istringstream stream(task_descriptor);
@@ -697,8 +697,8 @@
static void CheckAllUseCaseToString() {
CallForEachEnumValue<RendererSchedulerImpl::UseCase>(
- RendererSchedulerImpl::UseCase::FIRST_USE_CASE,
- RendererSchedulerImpl::UseCase::USE_CASE_COUNT,
+ RendererSchedulerImpl::UseCase::kFirstUseCase,
+ RendererSchedulerImpl::UseCase::kUseCaseCount,
&RendererSchedulerImpl::UseCaseToString);
}
@@ -893,7 +893,7 @@
::testing::ElementsAre(std::string("L1"), std::string("D1"),
std::string("C1"), std::string("D2"),
std::string("C2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
}
TEST_F(RendererSchedulerImplTest, TestDefaultPolicyWithSlowCompositor) {
@@ -908,7 +908,7 @@
::testing::ElementsAre(std::string("L1"), std::string("D1"),
std::string("C1"), std::string("D2"),
std::string("C2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
}
TEST_F(RendererSchedulerImplTest,
@@ -918,13 +918,13 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
EnableIdleTasks();
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
RunUntilIdle();
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("L1"), std::string("D1"),
std::string("D2"), std::string("C1"),
std::string("C2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -941,7 +941,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("L1"), std::string("D1"),
std::string("D2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
}
@@ -958,7 +958,7 @@
::testing::ElementsAre(std::string("L1"), std::string("D1"),
std::string("D2"), std::string("C1"),
std::string("C2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -966,13 +966,13 @@
TestCompositorPolicy_CompositorHandlesInput_LongGestureDuration) {
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
EnableIdleTasks();
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
base::TimeTicks loop_end_time =
clock_->NowTicks() + base::TimeDelta::FromMilliseconds(
UserModel::kMedianGestureDurationMillis * 2);
- // The UseCase::COMPOSITOR_GESTURE usecase initially deprioritizes compositor
+ // The UseCase::kCompositorGesture usecase initially deprioritizes compositor
// tasks (see TestCompositorPolicy_CompositorHandlesInput_WithTouchHandler)
// but if the gesture is long enough, compositor tasks get prioritized again.
while (clock_->NowTicks() < loop_end_time) {
@@ -991,7 +991,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("L1"), std::string("D1"),
std::string("D2")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -1001,13 +1001,13 @@
PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
EnableIdleTasks();
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
RunUntilIdle();
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("L1"), std::string("D1"),
std::string("D2"), std::string("C1"),
std::string("C2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -1018,14 +1018,14 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
EnableIdleTasks();
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
RunUntilIdle();
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("L1"), std::string("D1"),
std::string("D2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
scheduler_->DidHandleInputEventOnMainThread(
FakeInputEvent(blink::WebInputEvent::kGestureFlingStart),
@@ -1038,14 +1038,14 @@
PostTestTasks(&run_order, "L1 I1 D1 C1 D2 C2");
EnableIdleTasks();
- SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kDontSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
RunUntilIdle();
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("L1"), std::string("D1"),
std::string("D2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
scheduler_->DidHandleInputEventOnMainThread(
FakeInputEvent(blink::WebInputEvent::kGestureFlingStart),
@@ -1072,7 +1072,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("L1"), std::string("D1"),
std::string("D2"), std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
}
@@ -1097,7 +1097,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("D1"), std::string("D2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::TOUCHSTART, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kTouchstart, CurrentUseCase());
}
TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_DidAnimateForInput) {
@@ -1108,7 +1108,7 @@
scheduler_->DidAnimateForInputOnCompositorThread();
// Note DidAnimateForInputOnCompositorThread does not by itself trigger a
// policy update.
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EnableIdleTasks();
RunUntilIdle();
@@ -1116,7 +1116,7 @@
::testing::ElementsAre(std::string("D1"), std::string("D2"),
std::string("C1"), std::string("C2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -1129,7 +1129,7 @@
// A navigation occurs which creates a new Document thus resetting the task
// cost estimations.
scheduler_->DidStartProvisionalLoad(true);
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollUpdate);
PostTestTasks(&run_order, "C1 T1");
@@ -1147,14 +1147,14 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
SimulateExpensiveTasks(timer_task_runner_);
DoMainFrame();
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollUpdate);
PostTestTasks(&run_order, "C1 T1");
RunUntilIdle();
EXPECT_FALSE(TouchStartExpectedSoon());
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadGesture,
CurrentUseCase());
EXPECT_THAT(run_order, ::testing::ElementsAre(std::string("C1")));
@@ -1167,14 +1167,14 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
SimulateExpensiveTasks(timer_task_runner_);
DoMainFrame();
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kUndefined);
PostTestTasks(&run_order, "C1 T1");
RunUntilIdle();
EXPECT_FALSE(TouchStartExpectedSoon());
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
EXPECT_THAT(run_order,
@@ -1188,14 +1188,14 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
SimulateExpensiveTasks(timer_task_runner_);
DoMainFrameOnCriticalPath();
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
PostTestTasks(&run_order, "C1 T1");
RunUntilIdle();
EXPECT_FALSE(TouchStartExpectedSoon());
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
EXPECT_THAT(run_order,
@@ -1309,7 +1309,7 @@
std::string("L2"), std::string("C1"), std::string("T1"),
std::string("C2"), std::string("T2"), std::string("I1")};
EXPECT_THAT(run_order, ::testing::ElementsAreArray(loading_policy_expected));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::LOADING, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kLoading, CurrentUseCase());
// Advance 15s and try again, the loading policy should have ended and the
// task order should return to the NONE use case where loading tasks are no
@@ -1325,7 +1325,7 @@
std::string("L1"), std::string("D2"), std::string("C2"),
std::string("T2"), std::string("L2"), std::string("I1")};
EXPECT_THAT(run_order, ::testing::ElementsAreArray(default_order_expected));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
}
TEST_F(RendererSchedulerImplTest,
@@ -1341,7 +1341,7 @@
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
RunUntilIdle();
// Note compositor tasks are not prioritized.
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("D1"), std::string("C1"),
std::string("D2"), std::string("C2"),
@@ -1361,7 +1361,7 @@
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
RunUntilIdle();
// Note compositor tasks are not prioritized.
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("D1"), std::string("C1"),
std::string("D2"), std::string("C2"),
@@ -1382,7 +1382,7 @@
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
RunUntilIdle();
// Note compositor tasks deprioritized.
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
EXPECT_THAT(run_order,
::testing::ElementsAre(std::string("D1"), std::string("D2"),
@@ -1415,11 +1415,11 @@
TEST_F(RendererSchedulerImplTest,
EventForwardedToMainThread_MouseMove_WhenMouseDown_AfterMouseWheel) {
// Simulate a main thread driven mouse wheel scroll gesture.
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollUpdate);
RunUntilIdle();
EXPECT_FALSE(TouchStartExpectedSoon());
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadGesture,
CurrentUseCase());
// Now start a main thread mouse touch gesture. It should be detected as main
@@ -1438,7 +1438,7 @@
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
// Note compositor tasks are prioritized.
@@ -1467,7 +1467,7 @@
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
// Note compositor tasks are prioritized.
@@ -1491,7 +1491,7 @@
::testing::ElementsAre(std::string("D1"), std::string("D2"),
std::string("C1"), std::string("C2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -1510,7 +1510,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("D1"), std::string("D2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
}
@@ -1537,7 +1537,7 @@
::testing::ElementsAre(std::string("C1"), std::string("C2"),
std::string("D1"), std::string("D2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadGesture,
CurrentUseCase());
}
@@ -1566,7 +1566,7 @@
::testing::ElementsAre(std::string("D1"), std::string("D2"),
std::string("C1"), std::string("C2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase());
}
@@ -1587,7 +1587,7 @@
::testing::ElementsAre(std::string("D1"), std::string("C1"),
std::string("D2"), std::string("C2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
}
TEST_F(RendererSchedulerImplTest,
@@ -1607,7 +1607,7 @@
::testing::ElementsAre(std::string("D1"), std::string("C1"),
std::string("D2"), std::string("C2"),
std::string("I1")));
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
// Note compositor tasks are not prioritized.
scheduler_->DidHandleInputEventOnMainThread(
FakeInputEvent(blink::WebInputEvent::kKeyDown),
@@ -1616,7 +1616,7 @@
TEST_F(RendererSchedulerImplTest,
TestMainthreadScrollingUseCaseDoesNotStarveDefaultTasks) {
- SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kDontSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
EnableIdleTasks();
@@ -1641,23 +1641,23 @@
TEST_F(RendererSchedulerImplTest,
TestCompositorPolicyEnds_CompositorHandlesInput) {
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
}
TEST_F(RendererSchedulerImplTest,
TestCompositorPolicyEnds_MainThreadHandlesInput) {
- SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kDontSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling,
ForceUpdatePolicyAndGetCurrentUseCase());
clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
}
TEST_F(RendererSchedulerImplTest, TestTouchstartPolicyEndsAfterTimeout) {
@@ -1764,7 +1764,7 @@
// Without additional input, the scheduler should go into NONE
// use case but with scrolling expected where high-priority work is still
// anticipated.
- EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, CurrentUseCase());
EXPECT_TRUE(TouchStartExpectedSoon());
EXPECT_TRUE(is_anticipated_before);
EXPECT_TRUE(is_anticipated_after);
@@ -1777,7 +1777,7 @@
RunUntilIdle();
// Eventually the scheduler should go into the default use case where
// high-priority work is no longer anticipated.
- EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, CurrentUseCase());
EXPECT_FALSE(TouchStartExpectedSoon());
EXPECT_FALSE(is_anticipated_before);
EXPECT_FALSE(is_anticipated_after);
@@ -1827,14 +1827,14 @@
}
TEST_F(RendererSchedulerImplTest, SlowMainThreadInputEvent) {
- EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, CurrentUseCase());
// An input event should bump us into input priority.
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kGestureFlingStart),
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
RunUntilIdle();
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling, CurrentUseCase());
// Simulate the input event being queued for a very long time. The compositor
// task we post here represents the enqueued input task.
@@ -1846,12 +1846,12 @@
// Even though we exceeded the input priority escalation period, we should
// still be in main thread gesture since the input remains queued.
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling, CurrentUseCase());
// After the escalation period ends we should go back into normal mode.
clock_->Advance(priority_escalation_after_input_duration() * 2);
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, CurrentUseCase());
}
class RendererSchedulerImplWithMockSchedulerTest
@@ -2035,7 +2035,7 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
EXPECT_EQ(1, mock_scheduler_->update_policy_count_);
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
// We expect the first call to IsHighPriorityWorkAnticipated to be called
// after receiving an input event (but before the UpdateTask was processed) to
@@ -2623,7 +2623,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_FALSE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2638,7 +2638,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2658,7 +2658,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2680,7 +2680,7 @@
PostTestTasks(&run_order, "T1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_FALSE(LoadingTasksSeemExpensive());
EXPECT_TRUE(TimerTasksSeemExpensive());
@@ -2697,9 +2697,9 @@
DoMainFrame();
SimulateExpensiveTasks(timer_task_runner_);
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling,
ForceUpdatePolicyAndGetCurrentUseCase());
scheduler_->DidHandleInputEventOnCompositorThread(
@@ -2710,12 +2710,12 @@
WebInputEventResult::kHandledSystem);
clock_->Advance(priority_escalation_after_input_duration() * 2);
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
PostTestTasks(&run_order, "T1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_FALSE(LoadingTasksSeemExpensive());
EXPECT_TRUE(TimerTasksSeemExpensive());
@@ -2726,7 +2726,7 @@
}
TEST_F(RendererSchedulerImplTest,
- ExpensiveTimerTaskBlocked_UseCase_COMPOSITOR_GESTURE) {
+ ExpensiveTimerTaskBlocked_UseCase_kCompositorGesture) {
std::vector<std::string> run_order;
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
@@ -2738,7 +2738,7 @@
PostTestTasks(&run_order, "T1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_FALSE(LoadingTasksSeemExpensive());
@@ -2761,7 +2761,7 @@
PostTestTasks(&run_order, "T1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_FALSE(LoadingTasksSeemExpensive());
EXPECT_TRUE(TimerTasksSeemExpensive());
@@ -2803,7 +2803,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2821,7 +2821,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2847,7 +2847,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2864,7 +2864,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2881,7 +2881,7 @@
PostTestTasks(&run_order, "L1 D1");
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kNone, CurrentUseCase());
EXPECT_TRUE(HaveSeenABeginMainframe());
EXPECT_TRUE(LoadingTasksSeemExpensive());
EXPECT_FALSE(TimerTasksSeemExpensive());
@@ -2901,10 +2901,10 @@
PostTestTasks(&run_order, "C1 L1");
// Trigger main_thread_gesture UseCase
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase());
EXPECT_TRUE(LoadingTasksSeemExpensive());
@@ -2916,7 +2916,7 @@
TEST_F(RendererSchedulerImplTest, ModeratelyExpensiveTimer_NotBlocked) {
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kTouchMove);
RunUntilIdle();
for (int i = 0; i < 20; i++) {
@@ -2941,7 +2941,7 @@
RunUntilIdle();
EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase())
<< " i = " << i;
EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
@@ -2981,7 +2981,7 @@
RunUntilIdle();
EXPECT_TRUE(simulate_timer_task_ran_) << " i = " << i;
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
CurrentUseCase())
<< " i = " << i;
EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
@@ -2997,7 +2997,7 @@
TEST_F(RendererSchedulerImplTest,
ExpensiveTimer_NotBlocked_UseCase_MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kTouchMove);
RunUntilIdle();
for (int i = 0; i < 20; i++) {
@@ -3021,7 +3021,7 @@
base::TimeDelta::FromMilliseconds(10)));
RunUntilIdle();
- EXPECT_EQ(RendererSchedulerImpl::UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kMainThreadCustomInputHandling,
CurrentUseCase())
<< " i = " << i;
EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
@@ -3041,15 +3041,15 @@
TEST_F(RendererSchedulerImplTest,
EstimateLongestJankFreeTaskDuration_UseCase_NONE) {
- EXPECT_EQ(UseCase::NONE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, CurrentUseCase());
EXPECT_EQ(rails_response_time(),
scheduler_->EstimateLongestJankFreeTaskDuration());
}
TEST_F(RendererSchedulerImplTest,
- EstimateLongestJankFreeTaskDuration_UseCase_COMPOSITOR_GESTURE) {
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ EstimateLongestJankFreeTaskDuration_UseCase_kCompositorGesture) {
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(rails_response_time(),
scheduler_->EstimateLongestJankFreeTaskDuration());
@@ -3059,14 +3059,14 @@
TEST_F(RendererSchedulerImplTest,
DISABLED_EstimateLongestJankFreeTaskDuration_UseCase_) {
scheduler_->DidStartProvisionalLoad(true);
- EXPECT_EQ(UseCase::LOADING, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kLoading, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(rails_response_time(),
scheduler_->EstimateLongestJankFreeTaskDuration());
}
TEST_F(RendererSchedulerImplTest,
EstimateLongestJankFreeTaskDuration_UseCase_MAIN_THREAD_GESTURE) {
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollUpdate);
viz::BeginFrameArgs begin_frame_args = viz::BeginFrameArgs::Create(
BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
@@ -3082,7 +3082,7 @@
base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
RunUntilIdle();
- EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kMainThreadGesture, CurrentUseCase());
// 16ms frame - 5ms compositor work = 11ms for other stuff.
EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
@@ -3106,7 +3106,7 @@
base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
RunUntilIdle();
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase());
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling, CurrentUseCase());
// 16ms frame - 5ms compositor work = 11ms for other stuff.
EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
@@ -3115,7 +3115,7 @@
TEST_F(RendererSchedulerImplTest,
EstimateLongestJankFreeTaskDuration_UseCase_SYNCHRONIZED_GESTURE) {
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
viz::BeginFrameArgs begin_frame_args = viz::BeginFrameArgs::Create(
BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
@@ -3130,7 +3130,7 @@
base::Unretained(this), base::TimeDelta::FromMilliseconds(5)));
RunUntilIdle();
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase());
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase());
// 16ms frame - 5ms compositor work = 11ms for other stuff.
EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
@@ -3165,7 +3165,7 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
DoMainFrame();
SimulateExpensiveTasks(timer_task_runner_);
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
ForceTouchStartToBeExpectedSoon();
std::vector<std::string> run_order;
@@ -3187,7 +3187,7 @@
auto pause_handle = scheduler_->PauseRenderer();
DoMainFrame();
SimulateExpensiveTasks(timer_task_runner_);
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
ForceTouchStartToBeExpectedSoon();
std::vector<std::string> run_order;
@@ -3205,11 +3205,11 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
DoMainFrame();
SimulateExpensiveTasks(timer_task_runner_);
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kTouchStart),
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
- EXPECT_EQ(UseCase::TOUCHSTART, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kTouchstart, ForceUpdatePolicyAndGetCurrentUseCase());
std::vector<std::string> run_order;
PostTestTasks(&run_order, "T1 T2");
@@ -3227,7 +3227,7 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
DoMainFrame();
SimulateExpensiveTasks(timer_task_runner_);
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
viz::BeginFrameArgs begin_frame_args = viz::BeginFrameArgs::Create(
BEGINFRAME_FROM_HERE, 0, next_begin_frame_number_++, clock_->NowTicks(),
@@ -3236,7 +3236,7 @@
begin_frame_args.on_critical_path = true;
scheduler_->WillBeginFrame(begin_frame_args);
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE,
+ EXPECT_EQ(UseCase::kSynchronizedGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
std::vector<std::string> run_order;
@@ -3258,9 +3258,9 @@
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kMouseWheel),
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
- SimulateCompositorGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kDontSendTouchStart);
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
ForceTouchStartToBeExpectedSoon();
@@ -3287,7 +3287,7 @@
TEST_F(RendererSchedulerImplTest,
SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_expensive) {
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
base::TimeTicks first_throttled_run_time =
TaskQueueThrottler::AlignedThrottledRunTime(clock_->NowTicks());
@@ -3320,7 +3320,7 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase()) << "i = " << i;
// We expect the queue to get throttled on the second iteration which is
// when the system realizes the task is expensive.
@@ -3350,7 +3350,7 @@
TEST_F(RendererSchedulerImplTest,
SYNCHRONIZED_GESTURE_TimerTaskThrottling_TimersStopped) {
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
base::TimeTicks first_throttled_run_time =
TaskQueueThrottler::AlignedThrottledRunTime(clock_->NowTicks());
@@ -3384,7 +3384,7 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase()) << "i = " << i;
// Before the policy is updated the queue will be enabled. Subsequently it
// will be disabled until the throttled queue is pumped.
@@ -3411,7 +3411,7 @@
TEST_F(RendererSchedulerImplTest,
SYNCHRONIZED_GESTURE_TimerTaskThrottling_task_not_expensive) {
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
size_t count = 0;
// With the compositor task taking 10ms, there is enough time to run this 6ms
@@ -3441,7 +3441,7 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase()) << "i = " << i;
EXPECT_TRUE(scheduler_->TimerTaskQueue()->IsQueueEnabled()) << "i = " << i;
}
@@ -3452,7 +3452,7 @@
TEST_F(RendererSchedulerImplTest,
ExpensiveTimerTaskBlocked_SYNCHRONIZED_GESTURE_TouchStartExpected) {
SimulateExpensiveTasks(timer_task_runner_);
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
ForceTouchStartToBeExpectedSoon();
@@ -3468,7 +3468,7 @@
begin_frame_args.on_critical_path = true;
scheduler_->WillBeginFrame(begin_frame_args);
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE,
+ EXPECT_EQ(UseCase::kSynchronizedGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_TRUE(TimerTasksSeemExpensive());
@@ -3480,7 +3480,7 @@
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kTouchStart),
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
- EXPECT_EQ(UseCase::TOUCHSTART, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kTouchstart, ForceUpdatePolicyAndGetCurrentUseCase());
// First check that long idle is denied during the TOUCHSTART use case.
IdleHelper::Delegate* idle_delegate = scheduler_.get();
@@ -3501,19 +3501,19 @@
scheduler_->DidAnimateForInputOnCompositorThread();
// Note DidAnimateForInputOnCompositorThread does not by itself trigger a
// policy update.
- EXPECT_EQ(RendererSchedulerImpl::UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
// Make sure TouchStart causes a policy change.
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kTouchStart),
RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
- EXPECT_EQ(RendererSchedulerImpl::UseCase::TOUCHSTART,
+ EXPECT_EQ(RendererSchedulerImpl::UseCase::kTouchstart,
ForceUpdatePolicyAndGetCurrentUseCase());
}
TEST_F(RendererSchedulerImplTest, SYNCHRONIZED_GESTURE_CompositingExpensive) {
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
// With the compositor task taking 20ms, there is not enough time to run
// other tasks in the same 16ms frame. To avoid starvation, compositing tasks
@@ -3543,18 +3543,18 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase()) << "i = " << i;
}
// Timer tasks should not have been starved by the expensive compositor
// tasks.
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY,
+ EXPECT_EQ(TaskQueue::kNormalPriority,
scheduler_->CompositorTaskQueue()->GetQueuePriority());
EXPECT_EQ(1000u, run_order.size());
}
TEST_F(RendererSchedulerImplTest, MAIN_THREAD_CUSTOM_INPUT_HANDLING) {
- SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
// With the compositor task taking 20ms, there is not enough time to run
@@ -3585,19 +3585,19 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING, CurrentUseCase())
+ EXPECT_EQ(UseCase::kMainThreadCustomInputHandling, CurrentUseCase())
<< "i = " << i;
}
// Timer tasks should not have been starved by the expensive compositor
// tasks.
- EXPECT_EQ(TaskQueue::NORMAL_PRIORITY,
+ EXPECT_EQ(TaskQueue::kNormalPriority,
scheduler_->CompositorTaskQueue()->GetQueuePriority());
EXPECT_EQ(1000u, run_order.size());
}
TEST_F(RendererSchedulerImplTest, MAIN_THREAD_GESTURE) {
- SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
+ SimulateMainThreadGestureStart(TouchEventPolicy::kDontSendTouchStart,
blink::WebInputEvent::kGestureScrollBegin);
// With the compositor task taking 20ms, there is not enough time to run
@@ -3629,10 +3629,10 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kMainThreadGesture, CurrentUseCase()) << "i = " << i;
}
- EXPECT_EQ(TaskQueue::HIGH_PRIORITY,
+ EXPECT_EQ(TaskQueue::kHighPriority,
scheduler_->CompositorTaskQueue()->GetQueuePriority());
EXPECT_EQ(279u, run_order.size());
}
@@ -3649,7 +3649,7 @@
scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
ForceTouchStartToBeExpectedSoon();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_RESPONSE, GetRAILMode());
scheduler_->SetRAILModeObserver(nullptr);
}
@@ -3660,7 +3660,7 @@
EXPECT_CALL(observer, OnRAILModeChanged(v8::PERFORMANCE_ANIMATION)).Times(0);
EXPECT_FALSE(BeginFrameNotExpectedSoon());
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_ANIMATION, GetRAILMode());
scheduler_->SetRAILModeObserver(nullptr);
}
@@ -3672,10 +3672,10 @@
EXPECT_CALL(observer, OnRAILModeChanged(v8::PERFORMANCE_IDLE));
scheduler_->SetAllRenderWidgetsHidden(true);
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_IDLE, GetRAILMode());
scheduler_->SetAllRenderWidgetsHidden(false);
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_ANIMATION, GetRAILMode());
scheduler_->SetRAILModeObserver(nullptr);
}
@@ -3688,9 +3688,9 @@
scheduler_->DidStartProvisionalLoad(true);
EXPECT_EQ(v8::PERFORMANCE_LOAD, GetRAILMode());
- EXPECT_EQ(UseCase::LOADING, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kLoading, ForceUpdatePolicyAndGetCurrentUseCase());
scheduler_->OnFirstMeaningfulPaint();
- EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kNone, ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_ANIMATION, GetRAILMode());
scheduler_->SetRAILModeObserver(nullptr);
}
@@ -3703,14 +3703,14 @@
scheduler_->DidStartProvisionalLoad(true);
EXPECT_EQ(v8::PERFORMANCE_LOAD, GetRAILMode());
- EXPECT_EQ(UseCase::LOADING, ForceUpdatePolicyAndGetCurrentUseCase());
+ EXPECT_EQ(UseCase::kLoading, ForceUpdatePolicyAndGetCurrentUseCase());
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kGestureScrollBegin),
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
scheduler_->DidHandleInputEventOnCompositorThread(
FakeInputEvent(blink::WebInputEvent::kGestureScrollUpdate),
RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
- EXPECT_EQ(UseCase::COMPOSITOR_GESTURE,
+ EXPECT_EQ(UseCase::kCompositorGesture,
ForceUpdatePolicyAndGetCurrentUseCase());
EXPECT_EQ(v8::PERFORMANCE_ANIMATION, GetRAILMode());
scheduler_->SetRAILModeObserver(nullptr);
@@ -3719,10 +3719,10 @@
TEST_F(RendererSchedulerImplTest, UnthrottledTaskRunner) {
// Ensure neither suspension nor timer task throttling affects an unthrottled
// task runner.
- SimulateCompositorGestureStart(TouchEventPolicy::SEND_TOUCH_START);
+ SimulateCompositorGestureStart(TouchEventPolicy::kSendTouchStart);
scoped_refptr<TaskQueue> unthrottled_task_runner =
scheduler_->NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::UNTHROTTLED));
+ MainThreadTaskQueue::QueueType::kUnthrottled));
size_t timer_count = 0;
size_t unthrottled_count = 0;
@@ -3755,7 +3755,7 @@
mock_task_runner_->RunTasksWhile(
base::Bind(&RendererSchedulerImplTest::SimulatedCompositorTaskPending,
base::Unretained(this)));
- EXPECT_EQ(UseCase::SYNCHRONIZED_GESTURE, CurrentUseCase()) << "i = " << i;
+ EXPECT_EQ(UseCase::kSynchronizedGesture, CurrentUseCase()) << "i = " << i;
}
EXPECT_EQ(0u, timer_count);
@@ -3767,14 +3767,14 @@
scoped_refptr<MainThreadTaskQueue> loading_tq =
scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING);
+ MainThreadTaskQueue::QueueType::kFrameLoading);
scoped_refptr<TaskQueue> loading_control_tq = scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL);
+ MainThreadTaskQueue::QueueType::kFrameLoading_kControl);
scoped_refptr<MainThreadTaskQueue> timer_tq = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
scoped_refptr<MainThreadTaskQueue> unthrottled_tq =
scheduler_->NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::UNTHROTTLED));
+ MainThreadTaskQueue::QueueType::kUnthrottled));
EXPECT_EQ(scheduler_->DefaultTaskQueue()->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
@@ -3786,7 +3786,7 @@
scheduler_->GetVirtualTimeDomain());
EXPECT_EQ(scheduler_->VirtualTimeControlTaskQueue()->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
- EXPECT_EQ(scheduler_->V8TaskQueue()->GetTimeDomain(),
+ EXPECT_EQ(scheduler_->kV8TaskQueue()->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
// The main control task queue remains in the real time domain.
@@ -3802,22 +3802,22 @@
EXPECT_EQ(
scheduler_
- ->NewLoadingTaskQueue(MainThreadTaskQueue::QueueType::FRAME_LOADING)
+ ->NewLoadingTaskQueue(MainThreadTaskQueue::QueueType::kFrameLoading)
->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
EXPECT_EQ(scheduler_
->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE)
+ MainThreadTaskQueue::QueueType::kFrameThrottleable)
->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
EXPECT_EQ(scheduler_
->NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::UNTHROTTLED))
+ MainThreadTaskQueue::QueueType::kUnthrottled))
->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
EXPECT_EQ(scheduler_
->NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::TEST))
+ MainThreadTaskQueue::QueueType::kTest))
->GetTimeDomain(),
scheduler_->GetVirtualTimeDomain());
}
@@ -3848,10 +3848,10 @@
scheduler_->EnableVirtualTime();
scoped_refptr<MainThreadTaskQueue> timer_tq = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
scoped_refptr<MainThreadTaskQueue> unthrottled_tq =
scheduler_->NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::UNTHROTTLED));
+ MainThreadTaskQueue::QueueType::kUnthrottled));
scheduler_->DisableVirtualTimeForTesting();
EXPECT_EQ(scheduler_->DefaultTaskQueue()->GetTimeDomain(),
@@ -3864,7 +3864,7 @@
scheduler_->real_time_domain());
EXPECT_EQ(scheduler_->ControlTaskQueue()->GetTimeDomain(),
scheduler_->real_time_domain());
- EXPECT_EQ(scheduler_->V8TaskQueue()->GetTimeDomain(),
+ EXPECT_EQ(scheduler_->kV8TaskQueue()->GetTimeDomain(),
scheduler_->real_time_domain());
EXPECT_FALSE(scheduler_->VirtualTimeControlTaskQueue());
}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_web_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_web_scheduler_impl.cc
index ccf8ce0..acce1f0 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_web_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_web_scheduler_impl.cc
@@ -21,7 +21,7 @@
renderer_scheduler->IdleTaskRunner(),
renderer_scheduler->LoadingTaskQueue(),
renderer_scheduler->TimerTaskQueue(),
- renderer_scheduler->V8TaskQueue()),
+ renderer_scheduler->kV8TaskQueue()),
renderer_scheduler_(renderer_scheduler),
compositor_task_runner_(WebTaskRunnerImpl::Create(
renderer_scheduler_->CompositorTaskQueue())) {}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter.h b/third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter.h
index feab76f..df13291 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter.h
@@ -33,14 +33,15 @@
: TaskDurationMetricReporter(base::Histogram::FactoryGet(
metric_name,
1,
- static_cast<int>(TaskClass::COUNT),
- static_cast<int>(TaskClass::COUNT) + 1,
+ static_cast<int>(TaskClass::kCount),
+ static_cast<int>(TaskClass::kCount) + 1,
base::HistogramBase::kUmaTargetedHistogramFlag)) {}
~TaskDurationMetricReporter() {}
void RecordTask(TaskClass task_class, base::TimeDelta duration) {
- DCHECK_LT(static_cast<int>(task_class), static_cast<int>(TaskClass::COUNT));
+ DCHECK_LT(static_cast<int>(task_class),
+ static_cast<int>(TaskClass::kCount));
// Report only whole milliseconds to avoid overflow.
base::TimeDelta& unreported_duration =
unreported_task_duration_[static_cast<int>(task_class)];
@@ -59,7 +60,7 @@
TaskDurationMetricReporter(base::HistogramBase* histogram)
: task_duration_per_queue_type_histogram_(histogram) {}
- std::array<base::TimeDelta, static_cast<size_t>(TaskClass::COUNT)>
+ std::array<base::TimeDelta, static_cast<size_t>(TaskClass::kCount)>
unreported_task_duration_;
base::HistogramBase* task_duration_per_queue_type_histogram_;
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
index 7e0a0083..0feda19 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.cc
@@ -120,7 +120,7 @@
task_queue->SetTimeDomain(time_domain_.get());
// This blocks any tasks from |task_queue| until PumpThrottledTasks() to
// enforce task alignment.
- task_queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ task_queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
if (!task_queue->IsQueueEnabled())
return;
@@ -331,7 +331,7 @@
if (!unblock_until || unblock_until.value() > now) {
queue->InsertFenceAt(unblock_until.value());
} else if (unblock_until.value() == now) {
- queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
} else {
DCHECK_GE(unblock_until.value(), now);
}
@@ -365,7 +365,7 @@
switch (block_type.value()) {
case QueueBlockType::kAllTasks:
- queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
{
// Braces limit the scope for a declared variable. Does not compile
@@ -381,7 +381,7 @@
if (!queue->HasActiveFence()) {
// Insert a new non-fully blocking fence only when there is no fence
// already in order avoid undesired unblocking of old tasks.
- queue->InsertFence(TaskQueue::InsertFencePosition::NOW);
+ queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
}
break;
}
@@ -561,7 +561,7 @@
// Throttling is enabled and task queue should be blocked immediately
// to enforce task alignment.
- queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
+ queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
queue->SetTimeDomain(time_domain_.get());
UpdateQueueThrottlingState(lazy_now.Now(), queue);
}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
index f246846..8c0fa75 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler_unittest.cc
@@ -85,7 +85,7 @@
scheduler_.reset(new RendererSchedulerImpl(delegate_));
task_queue_throttler_ = scheduler_->task_queue_throttler();
timer_queue_ = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
}
void TearDown() override {
@@ -122,7 +122,7 @@
return true;
return task_queue_impl->GetFenceForTest() ==
static_cast<internal::EnqueueOrder>(
- internal::EnqueueOrderValues::BLOCKING_FENCE);
+ internal::EnqueueOrderValues::kBlockingFence);
}
protected:
@@ -740,7 +740,7 @@
std::vector<base::TimeTicks> run_times;
scoped_refptr<TaskQueue> second_queue = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
CPUTimeBudgetPool* pool =
task_queue_throttler_->CreateCPUTimeBudgetPool("test");
@@ -1066,7 +1066,7 @@
scoped_refptr<MainThreadTaskQueue> second_queue =
scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
task_queue_throttler_->IncreaseThrottleRefCount(timer_queue_.get());
task_queue_throttler_->IncreaseThrottleRefCount(second_queue.get());
@@ -1102,7 +1102,7 @@
std::vector<base::TimeTicks> run_times;
scoped_refptr<TaskQueue> second_queue = scheduler_->NewTimerTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE);
+ MainThreadTaskQueue::QueueType::kFrameThrottleable);
CPUTimeBudgetPool* pool1 =
task_queue_throttler_->CreateCPUTimeBudgetPool("test");
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.cc
index 04479ea..2bb8546 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/web_frame_scheduler_impl.cc
@@ -267,7 +267,7 @@
DCHECK(parent_web_view_scheduler_);
if (!loading_task_queue_) {
loading_task_queue_ = renderer_scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING);
+ MainThreadTaskQueue::QueueType::kFrameLoading);
loading_task_queue_->SetBlameContext(blame_context_);
loading_task_queue_->SetFrameScheduler(this);
loading_queue_enabled_voter_ =
@@ -281,7 +281,7 @@
DCHECK(parent_web_view_scheduler_);
if (!loading_control_task_queue_) {
loading_control_task_queue_ = renderer_scheduler_->NewLoadingTaskQueue(
- MainThreadTaskQueue::QueueType::FRAME_LOADING_CONTROL);
+ MainThreadTaskQueue::QueueType::kFrameLoading_kControl);
loading_control_task_queue_->SetBlameContext(blame_context_);
loading_control_task_queue_->SetFrameScheduler(this);
loading_control_queue_enabled_voter_ =
@@ -296,7 +296,7 @@
if (!throttleable_task_queue_) {
throttleable_task_queue_ = renderer_scheduler_->NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE)
+ MainThreadTaskQueue::QueueType::kFrameThrottleable)
.SetShouldReportWhenExecutionBlocked(true)
.SetCanBeThrottled(true)
.SetCanBeStopped(true)
@@ -328,7 +328,7 @@
if (!deferrable_task_queue_) {
deferrable_task_queue_ = renderer_scheduler_->NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::FRAME_THROTTLEABLE)
+ MainThreadTaskQueue::QueueType::kFrameThrottleable)
.SetShouldReportWhenExecutionBlocked(true)
.SetCanBeDeferred(true)
.SetCanBePaused(true));
@@ -346,7 +346,7 @@
if (!pausable_task_queue_) {
pausable_task_queue_ = renderer_scheduler_->NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::FRAME_PAUSABLE)
+ MainThreadTaskQueue::QueueType::kFramePausable)
.SetShouldReportWhenExecutionBlocked(true)
.SetCanBePaused(true));
pausable_task_queue_->SetBlameContext(blame_context_);
@@ -363,7 +363,7 @@
if (!unpausable_task_queue_) {
unpausable_task_queue_ = renderer_scheduler_->NewTaskQueue(
MainThreadTaskQueue::QueueCreationParams(
- MainThreadTaskQueue::QueueType::FRAME_UNPAUSABLE));
+ MainThreadTaskQueue::QueueType::kFrameUnpausable));
unpausable_task_queue_->SetBlameContext(blame_context_);
unpausable_task_queue_->SetFrameScheduler(this);
}
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler.h b/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler.h
index 23974ca..00d91ef 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler.h
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler.h
@@ -61,20 +61,20 @@
// runs out of immediate work, the virtual timebase will be incremented so
// that the next sceduled timer may fire. NOTE Tasks will be run in time
// order (as usual).
- ADVANCE,
+ kAdvance,
// In this policy virtual time is not allowed to advance. Delayed tasks
// posted to WebTaskRunners owned by any child WebFrameSchedulers will be
// paused, unless their scheduled run time is less than or equal to the
// current virtual time. Note non-delayed tasks will run as normal.
- PAUSE,
+ kPause,
// In this policy virtual time is allowed to advance unless there are
// pending network fetches associated any child WebFrameScheduler, or a
// document is being parsed on a background thread. Initially virtual time
// is not allowed to advance until we have seen at least one load. The aim
// being to try and make loading (more) deterministic.
- DETERMINISTIC_LOADING
+ kDeterministicLoading,
};
// Sets the virtual time policy, which is applied imemdiatly to all child
@@ -111,7 +111,7 @@
// It's possible for pages to send infinite messages which can arbitrarily
// block virtual time. We can prevent this by setting an upper limit on the
// number of tasks that can run before virtual time is advanced.
- // NB this anti-starvation logic doesn't apply to VirtualTimePolicy::PAUSE.
+ // NB this anti-starvation logic doesn't apply to VirtualTimePolicy::kPause.
virtual void SetMaxVirtualTimeTaskStarvationCount(
int max_task_starvation_count) = 0;
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc
index 324823c..00c398a4 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/web_view_scheduler_impl_unittest.cc
@@ -339,7 +339,7 @@
TEST_F(WebViewSchedulerImplTest, VirtualTime_NotAllowedToAdvance) {
std::vector<int> run_order;
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
web_view_scheduler_->EnableVirtualTime();
ThrottleableTaskQueue()->PostTask(
@@ -367,7 +367,7 @@
TEST_F(WebViewSchedulerImplTest, VirtualTime_AllowedToAdvance) {
std::vector<int> run_order;
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
web_view_scheduler_->EnableVirtualTime();
ThrottleableTaskQueue()->PostTask(
@@ -416,7 +416,7 @@
TEST_F(WebViewSchedulerImplTest, VirtualTimeSettings_NewWebFrameScheduler) {
std::vector<int> run_order;
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
web_view_scheduler_->EnableVirtualTime();
std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
@@ -432,7 +432,7 @@
mock_task_runner_->RunUntilIdle();
EXPECT_TRUE(run_order.empty());
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
mock_task_runner_->RunUntilIdle();
EXPECT_THAT(run_order, ElementsAre(1));
@@ -497,7 +497,7 @@
TEST_F(WebViewSchedulerImplTest, VirtualTimePauseCount_DETERMINISTIC_LOADING) {
web_view_scheduler_->SetVirtualTimePolicy(
- VirtualTimePolicy::DETERMINISTIC_LOADING);
+ VirtualTimePolicy::kDeterministicLoading);
EXPECT_TRUE(scheduler_->VirtualTimeAllowedToAdvance());
scheduler_->IncrementVirtualTimePauseCount();
@@ -522,7 +522,7 @@
TEST_F(WebViewSchedulerImplTest,
ScopedVirtualTimePauser_DETERMINISTIC_LOADING) {
web_view_scheduler_->SetVirtualTimePolicy(
- VirtualTimePolicy::DETERMINISTIC_LOADING);
+ VirtualTimePolicy::kDeterministicLoading);
std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
web_view_scheduler_->CreateWebFrameSchedulerImpl(
@@ -549,7 +549,7 @@
TEST_F(WebViewSchedulerImplTest,
MultipleScopedVirtualTimePausers_DETERMINISTIC_LOADING) {
web_view_scheduler_->SetVirtualTimePolicy(
- VirtualTimePolicy::DETERMINISTIC_LOADING);
+ VirtualTimePolicy::kDeterministicLoading);
std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
web_view_scheduler_->CreateWebFrameSchedulerImpl(
@@ -575,7 +575,7 @@
TEST_F(WebViewSchedulerImplTest, NestedMessageLoop_DETERMINISTIC_LOADING) {
web_view_scheduler_->SetVirtualTimePolicy(
- VirtualTimePolicy::DETERMINISTIC_LOADING);
+ VirtualTimePolicy::kDeterministicLoading);
EXPECT_TRUE(scheduler_->VirtualTimeAllowedToAdvance());
scheduler_->OnBeginNestedRunLoop();
@@ -591,7 +591,7 @@
std::unique_ptr<WebFrameSchedulerImpl> web_frame_scheduler =
web_view_scheduler_->CreateWebFrameSchedulerImpl(
nullptr, WebFrameScheduler::FrameType::kSubframe);
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
web_view_scheduler_->EnableVirtualTime();
ThrottleableTaskQueueForScheduler(web_frame_scheduler.get())
@@ -601,7 +601,7 @@
mock_task_runner_->RunUntilIdle();
EXPECT_TRUE(run_order.empty());
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
mock_task_runner_->RunUntilIdle();
EXPECT_THAT(run_order, ElementsAre(1));
@@ -645,7 +645,7 @@
base::TimeDelta::FromMilliseconds(5),
WTF::Bind(
[](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ scheduler->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
},
WTF::Unretained(web_view_scheduler_.get())));
@@ -706,7 +706,7 @@
base::TimeDelta::FromMilliseconds(1000),
WTF::Bind(
[](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ scheduler->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
},
WTF::Unretained(web_view_scheduler_.get())));
@@ -740,7 +740,7 @@
TEST_F(WebViewSchedulerImplTest, MaxVirtualTimeTaskStarvationCountOneHundred) {
web_view_scheduler_->EnableVirtualTime();
web_view_scheduler_->SetMaxVirtualTimeTaskStarvationCount(100);
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
int count = 0;
int delayed_task_run_at_count = 0;
@@ -755,7 +755,7 @@
base::TimeDelta::FromMilliseconds(1000),
WTF::Bind(
[](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ scheduler->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
},
WTF::Unretained(web_view_scheduler_.get())));
@@ -770,7 +770,7 @@
MaxVirtualTimeTaskStarvationCountOneHundredNestedMessageLoop) {
web_view_scheduler_->EnableVirtualTime();
web_view_scheduler_->SetMaxVirtualTimeTaskStarvationCount(100);
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
scheduler_->OnBeginNestedRunLoop();
int count = 0;
@@ -786,7 +786,7 @@
base::TimeDelta::FromMilliseconds(1000),
WTF::Bind(
[](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ scheduler->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
},
WTF::Unretained(web_view_scheduler_.get())));
@@ -799,7 +799,7 @@
TEST_F(WebViewSchedulerImplTest, MaxVirtualTimeTaskStarvationCountZero) {
web_view_scheduler_->EnableVirtualTime();
web_view_scheduler_->SetMaxVirtualTimeTaskStarvationCount(0);
- web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::ADVANCE);
+ web_view_scheduler_->SetVirtualTimePolicy(VirtualTimePolicy::kAdvance);
int count = 0;
int delayed_task_run_at_count = 0;
@@ -814,7 +814,7 @@
base::TimeDelta::FromMilliseconds(1000),
WTF::Bind(
[](WebViewScheduler* scheduler) {
- scheduler->SetVirtualTimePolicy(VirtualTimePolicy::PAUSE);
+ scheduler->SetVirtualTimePolicy(VirtualTimePolicy::kPause);
},
WTF::Unretained(web_view_scheduler_.get())));
diff --git a/third_party/WebKit/Source/platform/scheduler/test/fake_web_frame_scheduler.h b/third_party/WebKit/Source/platform/scheduler/test/fake_web_frame_scheduler.h
index 5e91995..066b578 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/fake_web_frame_scheduler.h
+++ b/third_party/WebKit/Source/platform/scheduler/test/fake_web_frame_scheduler.h
@@ -19,7 +19,7 @@
MainThreadTaskQueueForTest(QueueType queue_type)
: MainThreadTaskQueue(nullptr,
Spec(MainThreadTaskQueue::NameForQueueType(
- MainThreadTaskQueue::QueueType::TEST)),
+ MainThreadTaskQueue::QueueType::kTest)),
QueueCreationParams(queue_type),
nullptr) {}
~MainThreadTaskQueueForTest() {}
diff --git a/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.cc b/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.cc
index 7db1c29..d0a9e84 100644
--- a/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.cc
+++ b/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.cc
@@ -13,7 +13,7 @@
const Callback& callback,
base::TimeDelta reporting_interval)
: time_(now),
- thread_state_(ThreadState::PAUSED),
+ thread_state_(ThreadState::kPaused),
last_state_change_time_(now),
reporting_interval_(reporting_interval),
callback_(callback) {
@@ -23,15 +23,15 @@
ThreadLoadTracker::~ThreadLoadTracker() {}
void ThreadLoadTracker::Pause(base::TimeTicks now) {
- Advance(now, TaskState::IDLE);
- thread_state_ = ThreadState::PAUSED;
+ Advance(now, TaskState::kIdle);
+ thread_state_ = ThreadState::kPaused;
Reset(now);
}
void ThreadLoadTracker::Resume(base::TimeTicks now) {
- Advance(now, TaskState::IDLE);
- thread_state_ = ThreadState::ACTIVE;
+ Advance(now, TaskState::kIdle);
+ thread_state_ = ThreadState::kActive;
Reset(now);
}
@@ -47,12 +47,12 @@
start_time = std::max(last_state_change_time_, start_time);
end_time = std::max(last_state_change_time_, end_time);
- Advance(start_time, TaskState::IDLE);
- Advance(end_time, TaskState::TASK_RUNNING);
+ Advance(start_time, TaskState::kIdle);
+ Advance(end_time, TaskState::kTaskRunning);
}
void ThreadLoadTracker::RecordIdle(base::TimeTicks now) {
- Advance(now, TaskState::IDLE);
+ Advance(now, TaskState::kIdle);
}
namespace {
@@ -80,7 +80,7 @@
// when appropriate.
DCHECK_LE(time_, now);
- if (thread_state_ == ThreadState::PAUSED) {
+ if (thread_state_ == ThreadState::kPaused) {
// If the load tracker is paused, bail out early.
time_ = now;
return;
@@ -96,7 +96,7 @@
// Keep a running total of the time spent running tasks within the window
// and the total time.
- if (task_state == TaskState::TASK_RUNNING) {
+ if (task_state == TaskState::kTaskRunning) {
run_time_inside_window_ +=
Intersection(next_reporting_time_ - reporting_interval_,
next_reporting_time_, time_, time_ + delta);
@@ -106,9 +106,9 @@
if (time_ == next_reporting_time_) {
// Call |callback_| if need and update next callback time.
- if (thread_state_ == ThreadState::ACTIVE) {
+ if (thread_state_ == ThreadState::kActive) {
callback_.Run(time_, Load());
- DCHECK_EQ(thread_state_, ThreadState::ACTIVE);
+ DCHECK_EQ(thread_state_, ThreadState::kActive);
}
next_reporting_time_ += reporting_interval_;
run_time_inside_window_ = base::TimeDelta();
diff --git a/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.h b/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.h
index b7606a7d..d4db58c 100644
--- a/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.h
+++ b/third_party/WebKit/Source/platform/scheduler/util/thread_load_tracker.h
@@ -41,9 +41,9 @@
// TODO(altimin): Count wake-ups.
private:
- enum class ThreadState { ACTIVE, PAUSED };
+ enum class ThreadState { kActive, kPaused };
- enum class TaskState { TASK_RUNNING, IDLE };
+ enum class TaskState { kTaskRunning, kIdle };
// This function advances |time_| to |now|, calling |callback_|
// in the process (multiple times if needed).
