[scheduler] Use thread type from WebThreadCreationParams.

Use thread type passed to the scheduler from WebThreadCreationParams
instead of having to call SetThreadType manually.

R=kinuko@chromium.org

Change-Id: I28ea429917191d3f561774be7d2b54ac29322517
Reviewed-on: https://chromium-review.googlesource.com/973366Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#545165}

third_party/WebKit/Source/core/workers/WorkerThread.cpp

@@ -383,7 +383,6 @@ void WorkerThread::InitializeSchedulerOnWorkerThread(
   global_scope_scheduler_ =
       std::make_unique<scheduler::WorkerGlobalScopeScheduler>(
           web_thread_for_worker.GetWorkerScheduler());
-  web_thread_for_worker.GetWorkerScheduler()->SetThreadType(GetThreadType());
   waitable_event->Signal();
 }
 

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc

@@ -98,7 +98,5 @@ base::TimeTicks CompositorWorkerScheduler::NowTicks() {
   return base::TimeTicks::Now();
 }
 
-void CompositorWorkerScheduler::SetThreadType(WebThreadType thread_type) {}
-
 }  // namespace scheduler
 }  // namespace blink

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.h

@@ -40,7 +40,6 @@ class PLATFORM_EXPORT CompositorWorkerScheduler
                        base::TimeTicks start,
                        base::TimeTicks end,
                        base::Optional<base::TimeDelta> thread_time) override;
-  void SetThreadType(WebThreadType thread_type) override;
 
   // ChildScheduler:
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;

third_party/WebKit/Source/platform/scheduler/child/metrics_helper.cc

@@ -80,9 +80,5 @@ void MetricsHelper::RecordCommonTaskMetrics(
   }
 }
 
-void MetricsHelper::SetThreadType(WebThreadType thread_type) {
-  thread_type_ = thread_type;
-}
-
 }  // namespace scheduler
 }  // namespace blink

third_party/WebKit/Source/platform/scheduler/child/metrics_helper.h

@@ -44,8 +44,6 @@ class PLATFORM_EXPORT MetricsHelper {
                                base::TimeTicks end_time,
                                base::Optional<base::TimeDelta> thread_time);
 
-  void SetThreadType(WebThreadType thread_type);
-
  protected:
   WebThreadType thread_type_;
 

third_party/WebKit/Source/platform/scheduler/child/webthread_impl_for_worker_scheduler.cc

@@ -21,6 +21,7 @@ namespace scheduler {
 WebThreadImplForWorkerScheduler::WebThreadImplForWorkerScheduler(
     const WebThreadCreationParams& params)
     : thread_(new base::Thread(params.name ? params.name : std::string())),
+      thread_type_(params.thread_type),
       worker_scheduler_proxy_(
           params.frame_scheduler
               ? std::make_unique<WorkerSchedulerProxy>(params.frame_scheduler)
@@ -86,7 +87,7 @@ void WebThreadImplForWorkerScheduler::ShutdownOnThread(
 
 std::unique_ptr<WorkerScheduler>
 WebThreadImplForWorkerScheduler::CreateWorkerScheduler() {
-  return WorkerScheduler::Create(worker_scheduler_proxy_.get());
+  return WorkerScheduler::Create(thread_type_, worker_scheduler_proxy_.get());
 }
 
 void WebThreadImplForWorkerScheduler::WillDestroyCurrentMessageLoop() {

third_party/WebKit/Source/platform/scheduler/child/webthread_impl_for_worker_scheduler.h

@@ -70,6 +70,7 @@ class PLATFORM_EXPORT WebThreadImplForWorkerScheduler
   void ShutdownOnThread(base::WaitableEvent* completion);
 
   std::unique_ptr<base::Thread> thread_;
+  const WebThreadType thread_type_;
   std::unique_ptr<scheduler::WorkerSchedulerProxy> worker_scheduler_proxy_;
   std::unique_ptr<scheduler::WorkerScheduler> worker_scheduler_;
   std::unique_ptr<scheduler::WebSchedulerImpl> web_scheduler_;

third_party/WebKit/Source/platform/scheduler/child/worker_global_scope_scheduler_unittest.cc

@@ -32,6 +32,7 @@ class WorkerGlobalScopeSchedulerTest : public ::testing::Test {
   WorkerGlobalScopeSchedulerTest()
       : mock_task_runner_(new base::TestSimpleTaskRunner()),
         scheduler_(new WorkerSchedulerImpl(
+            WebThreadType::kTestThread,
             TaskQueueManagerForTest::Create(nullptr,
                                             mock_task_runner_,
                                             &clock_),

third_party/WebKit/Source/platform/scheduler/child/worker_metrics_helper.cc

@@ -9,8 +9,8 @@
 namespace blink {
 namespace scheduler {
 
-WorkerMetricsHelper::WorkerMetricsHelper()
-    : MetricsHelper(WebThreadType::kUnspecifiedWorkerThread),
+WorkerMetricsHelper::WorkerMetricsHelper(WebThreadType thread_type)
+    : MetricsHelper(thread_type),
       dedicated_worker_per_task_type_duration_reporter_(
           "RendererScheduler.TaskDurationPerTaskType.DedicatedWorker"),
       dedicated_worker_per_task_type_cpu_duration_reporter_(

third_party/WebKit/Source/platform/scheduler/child/worker_metrics_helper.h

@@ -16,7 +16,7 @@ namespace scheduler {
 
 class PLATFORM_EXPORT WorkerMetricsHelper : public MetricsHelper {
  public:
-  WorkerMetricsHelper();
+  explicit WorkerMetricsHelper(WebThreadType thread_type);
   ~WorkerMetricsHelper();
 
   void RecordTaskMetrics(WorkerTaskQueue* queue,
@@ -25,8 +25,6 @@ class PLATFORM_EXPORT WorkerMetricsHelper : public MetricsHelper {
                          base::TimeTicks end_time,
                          base::Optional<base::TimeDelta> thread_time);
 
-  using MetricsHelper::SetThreadType;
-
   void SetParentFrameType(FrameOriginType frame_type);
 
  private:

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler.cc

@@ -20,9 +20,10 @@ WorkerScheduler::~WorkerScheduler() = default;
 
 // static
 std::unique_ptr<WorkerScheduler> WorkerScheduler::Create(
+    WebThreadType thread_type,
     WorkerSchedulerProxy* proxy) {
-  return base::WrapUnique(new WorkerSchedulerImpl(
-      TaskQueueManager::TakeOverCurrentThread(), proxy));
+  return std::make_unique<WorkerSchedulerImpl>(
+      thread_type, TaskQueueManager::TakeOverCurrentThread(), proxy);
 }
 
 scoped_refptr<WorkerTaskQueue> WorkerScheduler::CreateTaskRunner() {

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler.h

@@ -25,7 +25,8 @@ class PLATFORM_EXPORT WorkerScheduler : public ChildScheduler {
  public:
   ~WorkerScheduler() override;
 
-  static std::unique_ptr<WorkerScheduler> Create(WorkerSchedulerProxy* proxy);
+  static std::unique_ptr<WorkerScheduler> Create(WebThreadType thread_type,
+                                                 WorkerSchedulerProxy* proxy);
 
   // Blink should use WorkerScheduler::DefaultTaskQueue instead of
   // ChildScheduler::DefaultTaskRunner.
@@ -35,8 +36,6 @@ class PLATFORM_EXPORT WorkerScheduler : public ChildScheduler {
   // initialization needed such as initializing idle period detection.
   virtual void Init() = 0;
 
-  virtual void SetThreadType(WebThreadType thread_type) = 0;
-
   virtual void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
                                const TaskQueue::Task& task,
                                base::TimeTicks start,

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.cc

@@ -46,6 +46,7 @@ base::TimeTicks MonotonicTimeInSecondsToTimeTicks(
 }  // namespace
 
 WorkerSchedulerImpl::WorkerSchedulerImpl(
+    WebThreadType thread_type,
     std::unique_ptr<TaskQueueManager> task_queue_manager,
     WorkerSchedulerProxy* proxy)
     : WorkerScheduler(
@@ -64,6 +65,7 @@ WorkerSchedulerImpl::WorkerSchedulerImpl(
       throttling_state_(
           proxy ? proxy->throttling_state()
                 : WebFrameScheduler::ThrottlingState::kNotThrottled),
+      worker_metrics_helper_(thread_type),
       weak_factory_(this) {
   thread_start_time_ = helper_->NowTicks();
   load_tracker_.Resume(thread_start_time_);
@@ -182,11 +184,6 @@ void WorkerSchedulerImpl::DidProcessTask(double start_time, double end_time) {
   load_tracker_.RecordTaskTime(start_time_ticks, end_time_ticks);
 }
 
-void WorkerSchedulerImpl::SetThreadType(WebThreadType thread_type) {
-  DCHECK_NE(thread_type, WebThreadType::kMainThread);
-  worker_metrics_helper_.SetThreadType(thread_type);
-}
-
 void WorkerSchedulerImpl::OnThrottlingStateChanged(
     WebFrameScheduler::ThrottlingState throttling_state) {
   throttling_state_ = throttling_state;

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.h

@@ -29,7 +29,8 @@ class PLATFORM_EXPORT WorkerSchedulerImpl : public WorkerScheduler,
                                             public IdleHelper::Delegate,
                                             public TaskTimeObserver {
  public:
-  WorkerSchedulerImpl(std::unique_ptr<TaskQueueManager> task_queue_manager,
+  WorkerSchedulerImpl(WebThreadType thread_type,
+                      std::unique_ptr<TaskQueueManager> task_queue_manager,
                       WorkerSchedulerProxy* proxy);
   ~WorkerSchedulerImpl() override;
 
@@ -60,8 +61,6 @@ class PLATFORM_EXPORT WorkerSchedulerImpl : public WorkerScheduler,
   SchedulerHelper* GetSchedulerHelperForTesting();
   base::TimeTicks CurrentIdleTaskDeadlineForTesting() const;
 
-  void SetThreadType(WebThreadType thread_type) override;
-
   // Virtual for test.
   virtual void OnThrottlingStateChanged(
       WebFrameScheduler::ThrottlingState throttling_state);

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl_unittest.cc

@@ -55,7 +55,9 @@ class WorkerSchedulerImplForTest : public WorkerSchedulerImpl {
  public:
   WorkerSchedulerImplForTest(std::unique_ptr<TaskQueueManager> manager,
                              base::SimpleTestTickClock* clock_)
-      : WorkerSchedulerImpl(std::move(manager), nullptr),
+      : WorkerSchedulerImpl(WebThreadType::kTestThread,
+                            std::move(manager),
+                            nullptr),
         clock_(clock_),
         timeline_(nullptr) {}
 

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_proxy_unittest.cc

@@ -25,7 +25,9 @@ class WorkerSchedulerImplForTest : public WorkerSchedulerImpl {
   WorkerSchedulerImplForTest(std::unique_ptr<TaskQueueManager> manager,
                              WorkerSchedulerProxy* proxy,
                              WaitableEvent* throtting_state_changed)
-      : WorkerSchedulerImpl(std::move(manager), proxy),
+      : WorkerSchedulerImpl(WebThreadType::kTestThread,
+                            std::move(manager),
+                            proxy),
         throtting_state_changed_(throtting_state_changed) {}
 
   void OnThrottlingStateChanged(