compositor-worker: Keep worker backing thread alive for the lifetime of the compositor thread.

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/Document.h"
 #include "core/dom/ExceptionCode.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/09 02:00:53]

Move this just before worker->initialize? At least, it doesn't need to be
initialized until we call worker->initialize.

[flackr, 2016/05/10 18:07:39]

Unless I'm mistaken, we have to ensure the shared backing thread is created and
an initialize task posted before calling worker->initialize because when we
create the worker client we need to create CompositorMutatorImpl (GC'd class) on
the compositor thread. This all happens before the worker is created so the
thread needs to have been attached before we can do the worker initialization.

You can see this at https://codereview.chromium.org/1895873006 in
createCompositorProxyClient (called during worker initialization).

I've added to the comment to explain this.

+
     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)
 {
     ASSERT(getExecutionContext()->isDocument());
     return new CompositorWorkerMessagingProxy(this);
 }
 
 } // namespace blink