[worklets] Split apart CompositorWorkerThread for sharing with AnimationWorkletThread.

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

-// Copyright 2015 The Chromium Authors. All rights reserved.
+// Copyright 2016 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/CompositorWorkerThread.h"
+#include "modules/compositorworker/AbstractCompositorWorkerThread.h"
 
-#include "bindings/core/v8/V8GCController.h"
-#include "bindings/core/v8/V8Initializer.h"
-#include "core/workers/InProcessWorkerObjectProxy.h"
 #include "core/workers/WorkerBackingThread.h"
-#include "core/workers/WorkerThreadStartupData.h"
-#include "modules/compositorworker/CompositorWorkerGlobalScope.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/TraceEvent.h"
 #include "platform/WaitableEvent.h"

[majidvp, 2016/08/08 12:46:48]

CrossThreadFunctional, TraceEvent and WaitanleEvent headers 
seem unused. Please remove.

[ikilpatrick, 2016/08/08 13:54:58]

Removed TraceEvent, CrossThreadFunctional used for crossThreadBind below;
WaitableEvent also used below.

[majidvp, 2016/08/08 14:43:06]

Acknowledged.

 #include "platform/WebThreadSupportingGC.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
@@ skipping 67 matching lines @@
 
     void shutdownOnThread(WaitableEvent* doneEvent)
     {
         m_thread->shutdown();
         doneEvent->signal();
     }
 
     std::unique_ptr<WorkerBackingThread> m_thread;
     bool m_initialized = false;
 
     static BackingThreadHolder* s_instance;

[majidvp, 2016/08/08 12:46:48]

Is |BackingThreadHolder| accessible here? You have removed it from 
CompositorWorkerThread but it is not redefined here.

[ikilpatrick, 2016/08/08 13:54:57]

Redefined just above?

[majidvp, 2016/08/08 14:43:06]

Acknowledged. Sorry I missed it!

 };
 
 BackingThreadHolder* BackingThreadHolder::s_instance = nullptr;
 
 } // namespace
 
-std::unique_ptr<CompositorWorkerThread> CompositorWorkerThread::create(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
-{
-    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::create");
-    ASSERT(isMainThread());
-    return wrapUnique(new CompositorWorkerThread(workerLoaderProxy, workerObjectProxy, timeOrigin));
-}
-
-CompositorWorkerThread::CompositorWorkerThread(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, InProcessWorkerObjectProxy& workerObjectProxy, double timeOrigin)
-    : WorkerThread(workerLoaderProxy, workerObjectProxy)
-    , m_workerObjectProxy(workerObjectProxy)
-    , m_timeOrigin(timeOrigin)
+AbstractCompositorWorkerThread::AbstractCompositorWorkerThread(PassRefPtr<WorkerLoaderProxy> workerLoaderProxy, WorkerReportingProxy& workerReportingProxy)
+    : WorkerThread(workerLoaderProxy, workerReportingProxy)
 {
 }
 
-CompositorWorkerThread::~CompositorWorkerThread()
+AbstractCompositorWorkerThread::~AbstractCompositorWorkerThread()
 {
 }
 
-WorkerBackingThread& CompositorWorkerThread::workerBackingThread()
+WorkerBackingThread& AbstractCompositorWorkerThread::workerBackingThread()
 {
     return *BackingThreadHolder::instance().thread();
 }
 
-WorkerOrWorkletGlobalScope* CompositorWorkerThread::createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData> startupData)
-{
-    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorWorkerThread::createWorkerGlobalScope");
-    return CompositorWorkerGlobalScope::create(this, std::move(startupData), m_timeOrigin);
-}
-
-ConsoleMessageStorage* CompositorWorkerThread::consoleMessageStorage()
-{
-    return toWorkerGlobalScope(globalScope())->consoleMessageStorage();
-}
-
-void CompositorWorkerThread::ensureSharedBackingThread()
+void AbstractCompositorWorkerThread::ensureSharedBackingThread()
 {
     DCHECK(isMainThread());
     BackingThreadHolder::ensureInstance();
 }
 
-void CompositorWorkerThread::clearSharedBackingThread()
+void AbstractCompositorWorkerThread::clearSharedBackingThread()
 {
     DCHECK(isMainThread());
     BackingThreadHolder::clear();
 }
 
-void CompositorWorkerThread::createSharedBackingThreadForTest()
+void AbstractCompositorWorkerThread::createSharedBackingThreadForTest()
 {
     BackingThreadHolder::createForTest();
 }
 
 } // namespace blink