[worklets] Make WorkerThread handle both Worker and Worklet global scopes.

third_party/WebKit/Source/core/workers/WorkerThreadTestHelper.h

 // 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 "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8CacheOptions.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/workers/WorkerBackingThread.h"
 #include "core/workers/WorkerClients.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "core/workers/WorkerThreadLifecycleObserver.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
@@ skipping 33 matching lines @@
     ~MockWorkerReportingProxy() override { }
 
     MOCK_METHOD2(reportExceptionMock, void(const String& errorMessage, SourceLocation*));
     void reportException(const String& errorMessage, std::unique_ptr<SourceLocation> location)
     {
         reportExceptionMock(errorMessage, location.get());
     }
     MOCK_METHOD1(reportConsoleMessage, void(ConsoleMessage*));
     MOCK_METHOD1(postMessageToPageInspector, void(const String&));
     MOCK_METHOD1(didEvaluateWorkerScript, void(bool success));
-    MOCK_METHOD1(workerGlobalScopeStarted, void(WorkerGlobalScope*));
+    MOCK_METHOD1(workerGlobalScopeStarted, void(WorkerOrWorkletGlobalScope*));
     MOCK_METHOD0(workerGlobalScopeClosed, void());
     MOCK_METHOD0(workerThreadTerminated, void());
     MOCK_METHOD0(willDestroyWorkerGlobalScope, void());
 };
 
 class MockWorkerThreadLifecycleObserver final : public GarbageCollectedFinalized<MockWorkerThreadLifecycleObserver>, public WorkerThreadLifecycleObserver {
     USING_GARBAGE_COLLECTED_MIXIN(MockWorkerThreadLifecycleObserver);
     WTF_MAKE_NONCOPYABLE(MockWorkerThreadLifecycleObserver);
 public:
     explicit MockWorkerThreadLifecycleObserver(WorkerThreadLifecycleContext* context)
         : WorkerThreadLifecycleObserver(context) { }
 
     MOCK_METHOD0(contextDestroyed, void());
 };
 
 class WorkerThreadForTest : public WorkerThread {
 public:
     WorkerThreadForTest(
         WorkerLoaderProxyProvider* mockWorkerLoaderProxyProvider,
         WorkerReportingProxy& mockWorkerReportingProxy)
         : WorkerThread(WorkerLoaderProxy::create(mockWorkerLoaderProxyProvider), mockWorkerReportingProxy)
         , m_workerBackingThread(WorkerBackingThread::createForTest("Test thread"))
         , m_scriptLoadedEvent(wrapUnique(new WaitableEvent()))
     {
     }
 
     ~WorkerThreadForTest() override { }
 
     WorkerBackingThread& workerBackingThread() override { return *m_workerBackingThread; }
+    ConsoleMessageStorage* consoleMessageStorage() final { return toWorkerGlobalScope(globalScope())->consoleMessageStorage(); }
 
-    WorkerGlobalScope* createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData>) override;
+    WorkerOrWorkletGlobalScope* createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData>) override;
 
     void waitUntilScriptLoaded()
     {
         m_scriptLoadedEvent->wait();
     }
 
     void scriptLoaded()
     {
         m_scriptLoadedEvent->signal();
     }
@@ skipping 58 matching lines @@
     }
 
     void exceptionThrown(const String&, std::unique_ptr<SourceLocation>) override
     {
     }
 
 private:
     WorkerThreadForTest* m_thread;
 };
 
-inline WorkerGlobalScope* WorkerThreadForTest::createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData> startupData)
+inline WorkerOrWorkletGlobalScope* WorkerThreadForTest::createWorkerGlobalScope(std::unique_ptr<WorkerThreadStartupData> startupData)
 {
     return new FakeWorkerGlobalScope(startupData->m_scriptURL, startupData->m_userAgent, this, std::move(startupData->m_starterOriginPrivilegeData), std::move(startupData->m_workerClients));
 }
 
 } // namespace blink