Rename WorkerThread to WorkerScript

third_party/WebKit/Source/core/workers/WorkerScriptTest.cpp

Index: third_party/WebKit/Source/core/workers/WorkerScriptTest.cpp
diff --git a/third_party/WebKit/Source/core/workers/WorkerThreadTest.cpp b/third_party/WebKit/Source/core/workers/WorkerScriptTest.cpp
similarity index 79%
rename from third_party/WebKit/Source/core/workers/WorkerThreadTest.cpp
rename to third_party/WebKit/Source/core/workers/WorkerScriptTest.cpp
index eb93613514f7b0729d63172b36602e463f8e04e5..4dededab1d76aa4fac35b614c0a39618fef8333b 100644
--- a/third_party/WebKit/Source/core/workers/WorkerThreadTest.cpp
+++ b/third_party/WebKit/Source/core/workers/WorkerScriptTest.cpp
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "core/workers/WorkerThread.h"
+#include "core/workers/WorkerScript.h"
 
 #include "bindings/core/v8/ScriptCallStack.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/workers/WorkerReportingProxy.h"
-#include "core/workers/WorkerThreadStartupData.h"
+#include "core/workers/WorkerScriptStartupData.h"
 #include "platform/NotImplemented.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
@@ -56,19 +56,19 @@ public:
     MOCK_METHOD1(didEvaluateWorkerScript, void(bool success));
     MOCK_METHOD1(workerGlobalScopeStarted, void(WorkerGlobalScope*));
     MOCK_METHOD0(workerGlobalScopeClosed, void());
-    MOCK_METHOD0(workerThreadTerminated, void());
+    MOCK_METHOD0(workerScriptTerminated, void());
     MOCK_METHOD0(willDestroyWorkerGlobalScope, void());
 };
 
-void notifyScriptLoadedEventToWorkerThreadForTest(WorkerThread*);
+void notifyScriptLoadedEventToWorkerScriptForTest(WorkerScript*);
 
 class FakeWorkerGlobalScope : public WorkerGlobalScope {
 public:
     typedef WorkerGlobalScope Base;
 
-    FakeWorkerGlobalScope(const KURL& url, const String& userAgent, WorkerThread* thread, PassOwnPtr<SecurityOrigin::PrivilegeData> starterOriginPrivilegeData, PassOwnPtrWillBeRawPtr<WorkerClients> workerClients)
-        : WorkerGlobalScope(url, userAgent, thread, monotonicallyIncreasingTime(), starterOriginPrivilegeData, workerClients)
-        , m_thread(thread)
+    FakeWorkerGlobalScope(const KURL& url, const String& userAgent, WorkerScript* script, PassOwnPtr<SecurityOrigin::PrivilegeData> starterOriginPrivilegeData, PassOwnPtrWillBeRawPtr<WorkerClients> workerClients)
+        : WorkerGlobalScope(url, userAgent, script, monotonicallyIncreasingTime(), starterOriginPrivilegeData, workerClients)
+        , m_script(script)
     {
     }
 
@@ -78,7 +78,7 @@ public:
 
     void scriptLoaded(size_t, size_t) override
     {
-        notifyScriptLoadedEventToWorkerThreadForTest(m_thread);
+        notifyScriptLoadedEventToWorkerScriptForTest(m_script);
     }
 
     // EventTarget
@@ -92,23 +92,23 @@ public:
     }
 
 private:
-    WorkerThread* m_thread;
+    WorkerScript* m_script;
 };
 
-class WorkerThreadForTest : public WorkerThread {
+class WorkerScriptForTest : public WorkerScript {
 public:
-    WorkerThreadForTest(
+    WorkerScriptForTest(
         WorkerLoaderProxyProvider* mockWorkerLoaderProxyProvider,
         WorkerReportingProxy& mockWorkerReportingProxy)
-        : WorkerThread(WorkerLoaderProxy::create(mockWorkerLoaderProxyProvider), mockWorkerReportingProxy)
+        : WorkerScript(WorkerLoaderProxy::create(mockWorkerLoaderProxyProvider), mockWorkerReportingProxy)
         , m_thread(WebThreadSupportingGC::create("Test thread"))
         , m_scriptLoadedEvent(adoptPtr(new WaitableEvent()))
     {
     }
 
-    ~WorkerThreadForTest() override { }
+    ~WorkerScriptForTest() override { }
 
-    // WorkerThread implementation:
+    // WorkerScript implementation:
     WebThreadSupportingGC& backingThread() override
     {
         return *m_thread;
@@ -116,10 +116,10 @@ public:
     void willDestroyIsolate() override
     {
         V8GCController::collectAllGarbageForTesting(v8::Isolate::GetCurrent());
-        WorkerThread::willDestroyIsolate();
+        WorkerScript::willDestroyIsolate();
     }
 
-    PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtr<WorkerThreadStartupData> startupData) override
+    PassRefPtrWillBeRawPtr<WorkerGlobalScope> createWorkerGlobalScope(PassOwnPtr<WorkerScriptStartupData> startupData) override
     {
         return adoptRefWillBeNoop(new FakeWorkerGlobalScope(startupData->m_scriptURL, startupData->m_userAgent, this, startupData->m_starterOriginPrivilegeData.release(), startupData->m_workerClients.release()));
     }
@@ -139,28 +139,28 @@ private:
     OwnPtr<WaitableEvent> m_scriptLoadedEvent;
 };
 
-void notifyScriptLoadedEventToWorkerThreadForTest(WorkerThread* thread)
+void notifyScriptLoadedEventToWorkerScriptForTest(WorkerScript* workerScript)
 {
-    static_cast<WorkerThreadForTest*>(thread)->scriptLoaded();
+    static_cast<WorkerScriptForTest*>(workerScript)->scriptLoaded();
 }
 
 } // namespace
 
-class WorkerThreadTest : public testing::Test {
+class WorkerScriptTest : public testing::Test {
 public:
     void SetUp() override
     {
         m_mockWorkerLoaderProxyProvider = adoptPtr(new MockWorkerLoaderProxyProvider());
         m_mockWorkerReportingProxy = adoptPtr(new MockWorkerReportingProxy());
         m_securityOrigin = SecurityOrigin::create(KURL(ParsedURLString, "http://fake.url/"));
-        m_workerThread = adoptRef(new WorkerThreadForTest(
+        m_workerScript = adoptRef(new WorkerScriptForTest(
             m_mockWorkerLoaderProxyProvider.get(),
             *m_mockWorkerReportingProxy));
     }
 
     void TearDown() override
     {
-        m_workerThread->workerLoaderProxy()->detachProvider(m_mockWorkerLoaderProxyProvider.get());
+        m_workerScript->workerLoaderProxy()->detachProvider(m_mockWorkerLoaderProxyProvider.get());
     }
 
     void start()
@@ -176,7 +176,7 @@ public:
 
         OwnPtrWillBeRawPtr<WorkerClients> clients = nullptr;
 
-        m_workerThread->start(WorkerThreadStartupData::create(
+        m_workerScript->start(WorkerScriptStartupData::create(
             KURL(ParsedURLString, "http://fake.url/"),
             "fake user agent",
             source,
@@ -191,7 +191,7 @@ public:
     void waitForInit()
     {
         OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
-        m_workerThread->backingThread().postTask(BLINK_FROM_HERE, new Task(threadSafeBind(&WaitableEvent::signal, AllowCrossThreadAccess(completionEvent.get()))));
+        m_workerScript->backingThread().postTask(BLINK_FROM_HERE, new Task(threadSafeBind(&WaitableEvent::signal, AllowCrossThreadAccess(completionEvent.get()))));
         completionEvent->wait();
     }
 
@@ -200,39 +200,39 @@ protected:
     {
         EXPECT_CALL(*m_mockWorkerReportingProxy, workerGlobalScopeStarted(_)).Times(1);
         EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(true)).Times(1);
-        EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated()).Times(1);
+        EXPECT_CALL(*m_mockWorkerReportingProxy, workerScriptTerminated()).Times(1);
         EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope()).Times(1);
     }
 
     RefPtr<SecurityOrigin> m_securityOrigin;
     OwnPtr<MockWorkerLoaderProxyProvider> m_mockWorkerLoaderProxyProvider;
     OwnPtr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
-    RefPtr<WorkerThreadForTest> m_workerThread;
+    RefPtr<WorkerScriptForTest> m_workerScript;
 };
 
-TEST_F(WorkerThreadTest, StartAndStop)
+TEST_F(WorkerScriptTest, StartAndStop)
 {
     expectWorkerLifetimeReportingCalls();
     start();
     waitForInit();
-    m_workerThread->terminateAndWait();
+    m_workerScript->terminateAndWait();
 }
 
-TEST_F(WorkerThreadTest, StartAndStopImmediately)
+TEST_F(WorkerScriptTest, StartAndStopImmediately)
 {
     EXPECT_CALL(*m_mockWorkerReportingProxy, workerGlobalScopeStarted(_))
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(_))
         .Times(AtMost(1));
-    EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated())
+    EXPECT_CALL(*m_mockWorkerReportingProxy, workerScriptTerminated())
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope())
         .Times(AtMost(1));
     start();
-    m_workerThread->terminateAndWait();
+    m_workerScript->terminateAndWait();
 }
 
-TEST_F(WorkerThreadTest, StartAndStopOnScriptLoaded)
+TEST_F(WorkerScriptTest, StartAndStopOnScriptLoaded)
 {
     // Use a JavaScript source code that makes an infinite loop so that we can
     // catch some kind of issues as a timeout.
@@ -242,13 +242,13 @@ TEST_F(WorkerThreadTest, StartAndStopOnScriptLoaded)
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(_))
         .Times(AtMost(1));
-    EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated())
+    EXPECT_CALL(*m_mockWorkerReportingProxy, workerScriptTerminated())
         .Times(AtMost(1));
     EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope())
         .Times(AtMost(1));
     startWithSourceCode(source);
-    m_workerThread->waitUntilScriptLoaded();
-    m_workerThread->terminateAndWait();
+    m_workerScript->waitUntilScriptLoaded();
+    m_workerScript->terminateAndWait();
 }
 
 } // namespace blink