compositor-worker: Initialize CW machinery plumbing to compositor and fire CW rAF callbacks.

third_party/WebKit/Source/modules/compositorworker/CompositorWorker.cpp

 // Copyright 2015 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 "modules/compositorworker/CompositorWorker.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "core/dom/CompositorProxyClient.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/page/ChromeClient.h"
 #include "core/workers/WorkerClients.h"
 #include "modules/EventTargetModules.h"
 #include "modules/compositorworker/CompositorWorkerMessagingProxy.h"
+#include "modules/compositorworker/CompositorWorkerThread.h"
 
 namespace blink {
 
 inline CompositorWorker::CompositorWorker(ExecutionContext* context)
     : InProcessWorkerBase(context)
 {
 }
 
 CompositorWorker* CompositorWorker::create(ExecutionContext* context, const String& url, ExceptionState& exceptionState)
 {
+    // Ensure the compositor worker backing thread is ready.
+    CompositorWorkerThread::ensureSharedBackingThread();

[haraken, 2016/05/06 02:45:51]

Should we call this after worker->initialize has finished?

[flackr, 2016/05/06 18:15:07]

Unless I'm mistaken, we have to ensure the shared backing thread is created
before calling worker->initialize because when we create the worker client we
need to create CompositorMutatorImpl (GC'd class) on the compositor thread. The
thread needs to have been attached before we can do that.

+
     ASSERT(isMainThread());
     Document* document = toDocument(context);
     if (!document->page()) {
         exceptionState.throwDOMException(InvalidAccessError, "The context provided is invalid.");
         return nullptr;
     }
     CompositorWorker* worker = new CompositorWorker(context);
     if (worker->initialize(context, url, exceptionState))
         return worker;
     return nullptr;
 }
 
 CompositorWorker::~CompositorWorker()
 {
     ASSERT(isMainThread());
 }
 
 const AtomicString& CompositorWorker::interfaceName() const
 {
     return EventTargetNames::CompositorWorker;
 }
 
-InProcessWorkerGlobalScopeProxy* CompositorWorker::createInProcessWorkerGlobalScopeProxy(ExecutionContext* worker)
+InProcessWorkerGlobalScopeProxy* CompositorWorker::createInProcessWorkerGlobalScopeProxy(ExecutionContext* context)
 {
-    ASSERT(getExecutionContext()->isDocument());
-    return new CompositorWorkerMessagingProxy(this);
+    Document* document = toDocument(context);
+    WorkerClients* workerClients = WorkerClients::create();
+    provideCompositorProxyClientTo(workerClients, document->frame()->chromeClient().createCompositorProxyClient());

[haraken, 2016/05/06 02:45:51]

I'm not sure if this is a good way to inject the worker client. Shared workers
and dedicated workers create their worker clients via
WebWorkerContentSettingsClientProxy.

+falken +kinuko

+    return new CompositorWorkerMessagingProxy(this, workerClients);
 }
 
 } // namespace blink