compositor worker: Use a WebThread for the compositor thread.

content/child/blink_platform_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/blink_platform_impl.h"
 
 #include <math.h>
 
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "base/time/time.h"
 #include "base/trace_event/memory_allocator_dump_guid.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "blink/public/resources/grit/blink_image_resources.h"
 #include "blink/public/resources/grit/blink_resources.h"
 #include "build/build_config.h"
 #include "components/mime_util/mime_util.h"
 #include "components/scheduler/child/web_task_runner_impl.h"
 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
+#include "components/scheduler/child/worker_scheduler.h"
 #include "content/app/resources/grit/content_resources.h"
 #include "content/app/strings/grit/content_strings.h"
 #include "content/child/background_sync/background_sync_provider.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/content_child_helpers.h"
 #include "content/child/geofencing/web_geofencing_provider_impl.h"
 #include "content/child/navigator_connect/service_port_provider.h"
 #include "content/child/notifications/notification_dispatcher.h"
 #include "content/child/notifications/notification_manager.h"
 #include "content/child/permissions/permission_dispatcher.h"
@@ skipping 32 matching lines @@
 using blink::WebThemeEngine;
 using blink::WebURL;
 using blink::WebURLError;
 using blink::WebURLLoader;
 using scheduler::WebThreadImplForWorkerScheduler;
 
 namespace content {
 
 namespace {
 
+class CompositorWorkerScheduler : public scheduler::WorkerScheduler {

[Sami, 2016/01/14 13:55:05]

Would you mind putting this to
components/scheduler/renderer/compositor_worker_scheduler.{cc,h} instead? Right
now there's not much here but I think we might want to integrate this more
closely with the other scheduling machinery in the future.

[sadrul, 2016/01/14 15:20:40]

Done (moved to */child/* instead of in */renderer/* since this is going to be
used from here in content/child/).

+ public:
+  explicit CompositorWorkerScheduler(base::Thread* thread) : thread_(thread) {}
+  ~CompositorWorkerScheduler() override {}
+
+  // WorkerScheduler:
+  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override {
+    return thread_->task_runner();

[Sami, 2016/01/14 13:55:05]

If we do decide to land this pass through scheduler as a first step, could you
add a TODO here for adding an actual scheduler here and making sure performance
does not regress?

[sadrul, 2016/01/14 15:20:40]

Done.

+  }
+
+  scoped_refptr<scheduler::SingleThreadIdleTaskRunner> IdleTaskRunner()
+      override {
+    return nullptr;

[Sami, 2016/01/14 13:55:05]

Presumably the compositor worker will need to do some garbage collection at some
point? This is normally done using idle tasks, but if we don't support them v8
falls back to inline GC, which might cause janks. That might be fine for now,
but let's at least have a TODO here mentioning this.

[sadrul, 2016/01/14 15:20:40]

Done.

+  }
+
+  bool CanExceedIdleDeadlineIfRequired() const override { return false; }
+
+  bool ShouldYieldForHighPriorityWork() override { return false; }
+
+  void AddTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) override {
+    thread_->message_loop()->AddTaskObserver(task_observer);
+  }
+
+  void RemoveTaskObserver(
+      base::MessageLoop::TaskObserver* task_observer) override {
+    thread_->message_loop()->RemoveTaskObserver(task_observer);
+  }
+
+  void Init() override {}
+  void Shutdown() override {}
+
+ private:
+  base::Thread* thread_;
+  DISALLOW_COPY_AND_ASSIGN(CompositorWorkerScheduler);
+};
+
 class WebThreadForCompositor : public WebThreadImplForWorkerScheduler {
  public:
   explicit WebThreadForCompositor(base::Thread::Options options)
       : WebThreadImplForWorkerScheduler("Compositor", options) {
     Init();
   }
   ~WebThreadForCompositor() override {}
 
  private:
   // WebThreadImplForWorkerScheduler:
-  bool UseThreadTaskRunnerAsDefault() const override { return true; }
+  scoped_ptr<scheduler::WorkerScheduler> CreateWorkerScheduler() override {
+    return make_scoped_ptr(new CompositorWorkerScheduler(thread()));
+  }
 
   DISALLOW_COPY_AND_ASSIGN(WebThreadForCompositor);
 };
 
 class WebWaitableEventImpl : public blink::WebWaitableEvent {
  public:
   WebWaitableEventImpl(ResetPolicy policy, InitialState state) {
     bool manual_reset = policy == ResetPolicy::Manual;
     bool initially_signaled = state == InitialState::Signaled;
     impl_.reset(new base::WaitableEvent(manual_reset, initially_signaled));
@@ skipping 1221 matching lines @@
   return WebString::fromUTF8(ui::KeycodeConverter::DomKeyToKeyString(
       static_cast<ui::DomKey>(dom_key)));
 }
 
 int BlinkPlatformImpl::domKeyEnumFromString(const WebString& key_string) {
   return static_cast<int>(
       ui::KeycodeConverter::KeyStringToDomKey(key_string.utf8()));
 }
 
 }  // namespace content