Fix a race condition during worker thread initialization

Source/core/workers/WorkerThreadTest.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 "config.h"
 #include "core/workers/WorkerThread.h"
 
 #include "core/inspector/ConsoleMessage.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/NotImplemented.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebWaitableEvent.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using testing::_;
+using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 using testing::Mock;
 
 namespace blink {
 
 namespace {
 class MockWorkerLoaderProxyProvider : public WorkerLoaderProxyProvider {
 public:
     MockWorkerLoaderProxyProvider() { }
@@ skipping 124 matching lines @@
 class WorkerThreadTest : 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_mockWorkerLoaderProxyProvider.get(),
             *m_mockWorkerReportingProxy));
-        ExpectWorkerLifetimeReportingCalls();
     }
 
     void TearDown() override
     {
         m_workerThread->workerLoaderProxy()->detachProvider(m_mockWorkerLoaderProxyProvider.get());
     }
 
-    void startAndWaitForInit()
+    void start()
     {
-        OwnPtr<WebWaitableEvent> completionEvent = adoptPtr(Platform::current()->createWaitableEvent());
-
         OwnPtr<Vector<CSPHeaderAndType>> headers = adoptPtr(new Vector<CSPHeaderAndType>());
         CSPHeaderAndType headerAndType("contentSecurityPolicy", ContentSecurityPolicyHeaderTypeReport);
         headers->append(headerAndType);
 
         OwnPtrWillBeRawPtr<WorkerClients> clients = nullptr;
 
         m_workerThread->start(WorkerThreadStartupData::create(
             KURL(ParsedURLString, "http://fake.url/"),
             "fake user agent",
             "//fake source code",
             nullptr,
             DontPauseWorkerGlobalScopeOnStart,
             headers.release(),
             m_securityOrigin.get(),
             clients.release(),
             V8CacheOptionsDefault));
+    }
+
+    void waitForInit()
+    {
+        OwnPtr<WebWaitableEvent> completionEvent = adoptPtr(Platform::current()->createWaitableEvent());
         m_workerThread->backingThread().postTask(FROM_HERE, new SignalTask(completionEvent.get()));
         completionEvent->wait();
     }
 
     void postWakeUpTask(long long waitMs)
     {
         WebScheduler* scheduler = m_workerThread->backingThread().platformThread().scheduler();
 
         // The idle task will get posted on an after wake up queue, so we need another task
         // posted at the right time to wake the system up.  We don't know the right delay here
         // since the thread can take a variable length of time to be responsive, however this
         // isn't a problem when posting a delayed task from within a task on the worker thread.
         scheduler->postLoadingTask(FROM_HERE, new PostDelayedWakeupTask(scheduler, waitMs));
     }
 
 protected:
-    void ExpectWorkerLifetimeReportingCalls()
+    void expectWorkerLifetimeReportingCalls()
     {
         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, willDestroyWorkerGlobalScope()).Times(1);
     }
 
     RefPtr<SecurityOrigin> m_securityOrigin;
     OwnPtr<MockWorkerLoaderProxyProvider> m_mockWorkerLoaderProxyProvider;
     OwnPtr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
     RefPtr<WorkerThreadForTest> m_workerThread;
 };
 
 TEST_F(WorkerThreadTest, StartAndStop)
 {
-    startAndWaitForInit();
+    expectWorkerLifetimeReportingCalls();
+    start();
+    waitForInit();
     m_workerThread->terminateAndWait();
 }
 
+TEST_F(WorkerThreadTest, StartAndStopImmediately)
+{
+    EXPECT_CALL(*m_mockWorkerReportingProxy, workerGlobalScopeStarted(_)).Times(AnyNumber());

[kinuko, 2015/06/16 01:35:19]

AnyNumber() -> AtMostOne(1) ?

[Sami, 2015/06/16 16:03:45]

Ah, neat, I didn't know that!

+    EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(true)).Times(AnyNumber());
+    EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated()).Times(AnyNumber());
+    EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope()).Times(AnyNumber());
+    start();
+    m_workerThread->terminateAndWait();
+}
+
 TEST_F(WorkerThreadTest, GcOccursWhileIdle)
 {
     OwnPtr<WebWaitableEvent> gcDone = adoptPtr(Platform::current()->createWaitableEvent());
 
     ON_CALL(*m_workerThread, doIdleGc(_)).WillByDefault(Invoke(
         [&gcDone](double)
         {
             gcDone->signal();
             return false;
         }));
 
     EXPECT_CALL(*m_workerThread, doIdleGc(_)).Times(testing::AtLeast(1));
 
-    startAndWaitForInit();
+    expectWorkerLifetimeReportingCalls();
+    start();
+    waitForInit();
     postWakeUpTask(500ul);
 
     gcDone->wait();
     m_workerThread->terminateAndWait();
 };
 
 class RepeatingTask : public WebThread::Task {
 public:
     RepeatingTask(WebScheduler* scheduler, WebWaitableEvent* completion)
         : RepeatingTask(scheduler, completion, 0) { }
@@ skipping 23 matching lines @@
     WebWaitableEvent* m_completion;
     int m_taskCount;
 };
 
 TEST_F(WorkerThreadTest, GcDoesNotOccurWhenNotIdle)
 {
     OwnPtr<WebWaitableEvent> completion = adoptPtr(Platform::current()->createWaitableEvent());
 
     EXPECT_CALL(*m_workerThread, doIdleGc(_)).Times(0);
 
-    startAndWaitForInit();
+    expectWorkerLifetimeReportingCalls();
+    start();
+    waitForInit();
 
     WebScheduler* scheduler = m_workerThread->backingThread().platformThread().scheduler();
 
     // Post a repeating task that should prevent any GC from happening.
     scheduler->postLoadingTask(FROM_HERE, new RepeatingTask(scheduler, completion.get()));
 
     completion->wait();
 
     // Make sure doIdleGc has not been called by this stage.
     Mock::VerifyAndClearExpectations(m_workerThread.get());
 
     m_workerThread->terminateAndWait();
 }
 
 } // namespace blink