Prepare DedicatedWorker for per thread heap

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp

 // 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 "core/loader/ThreadableLoader.h"
 
 #include "core/dom/ExecutionContextTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 69 matching lines @@
     return !error.isCancellation();
 }
 
 KURL successURL() { return KURL(KURL(), "http://example.com/success"); }
 KURL errorURL() { return KURL(KURL(), "http://example.com/error"); }
 KURL redirectURL() { return KURL(KURL(), "http://example.com/redirect"); }
 KURL redirectLoopURL() { return KURL(KURL(), "http://example.com/loop"); }
 
 enum ThreadableLoaderToTest {
     DocumentThreadableLoaderTest,
-    WorkerThreadableLoaderTest
+    WorkerThreadableLoaderTest,
+    PerThreadHeapEnabledWorkerThreadableLoaderTest
 };
 
 class ThreadableLoaderTestHelper {
 public:
     virtual ~ThreadableLoaderTestHelper() { }
 
     virtual void createLoader(ThreadableLoaderClient*, CrossOriginRequestPolicy) = 0;
     virtual void startLoader(const ResourceRequest&) = 0;
     virtual void cancelLoader() = 0;
     virtual void cancelAndClearLoader() = 0;
@@ skipping 54 matching lines @@
 private:
     Document& document() { return m_dummyPageHolder->document(); }
 
     std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Checkpoint m_checkpoint;
     Persistent<DocumentThreadableLoader> m_loader;
 };
 
 class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper, public WorkerLoaderProxyProvider {
 public:
-    WorkerThreadableLoaderTestHelper()
+    WorkerThreadableLoaderTestHelper(ThreadHeapMode threadHeapMode)
         : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1)))
+        , m_threadHeapMode(threadHeapMode)
     {
     }
 
     void createLoader(ThreadableLoaderClient* client, CrossOriginRequestPolicy crossOriginRequestPolicy) override
     {
         std::unique_ptr<WaitableEvent> completionEvent = wrapUnique(new WaitableEvent());
         postTaskToWorkerGlobalScope(BLINK_FROM_HERE,
             createCrossThreadTask(
                 &WorkerThreadableLoaderTestHelper::workerCreateLoader,
                 crossThreadUnretained(this),
@@ skipping 57 matching lines @@
                 n));
         completionEvent->wait();
     }
 
     void onSetUp() override
     {
         m_mockWorkerReportingProxy = wrapUnique(new MockWorkerReportingProxy());
         m_securityOrigin = document().getSecurityOrigin();
         m_workerThread = wrapUnique(new WorkerThreadForTest(
             this,
-            *m_mockWorkerReportingProxy));
+            *m_mockWorkerReportingProxy,
+            m_threadHeapMode));
 
         expectWorkerLifetimeReportingCalls();
         m_workerThread->startWithSourceCode(m_securityOrigin.get(), "//fake source code");
         m_workerThread->waitForInit();
     }
 
     void onServeRequests() override
     {
         testing::runPendingTasks();
     }
@@ skipping 77 matching lines @@
     }
 
     RefPtr<SecurityOrigin> m_securityOrigin;
     std::unique_ptr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
     std::unique_ptr<WorkerThreadForTest> m_workerThread;
 
     std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Checkpoint m_checkpoint;
     // |m_loader| must be touched only from the worker thread only.
     CrossThreadPersistent<ThreadableLoader> m_loader;
+    ThreadHeapMode m_threadHeapMode;

[nhiroki, 2016/09/21 05:32:59]

Can you add 'const' for clarifying that the heap mode is never changed during
operations.

[keishi, 2016/09/21 09:16:11]

Done.

 };
 
 class ThreadableLoaderTest : public ::testing::TestWithParam<ThreadableLoaderToTest> {
 public:
     ThreadableLoaderTest()
     {
         switch (GetParam()) {
         case DocumentThreadableLoaderTest:
             m_helper = wrapUnique(new DocumentThreadableLoaderTestHelper);
             break;
         case WorkerThreadableLoaderTest:
-            m_helper = wrapUnique(new WorkerThreadableLoaderTestHelper);
+            m_helper = wrapUnique(new WorkerThreadableLoaderTestHelper(MainThreadHeapMode));
+            break;
+        case PerThreadHeapEnabledWorkerThreadableLoaderTest:
+            m_helper = wrapUnique(new WorkerThreadableLoaderTestHelper(PerThreadHeapMode));
             break;
         }
     }
 
     void startLoader(const KURL& url)
     {
         ResourceRequest request(url);
         request.setRequestContext(WebURLRequest::RequestContextObject);
         m_helper->startLoader(request);
     }
@@ skipping 86 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(Document,
     ThreadableLoaderTest,
     ::testing::Values(DocumentThreadableLoaderTest));
 
 INSTANTIATE_TEST_CASE_P(Worker,
     ThreadableLoaderTest,
     ::testing::Values(WorkerThreadableLoaderTest));
 
+INSTANTIATE_TEST_CASE_P(PerThreadHeapEnabledWorker,
+    ThreadableLoaderTest,
+    ::testing::Values(PerThreadHeapEnabledWorkerThreadableLoaderTest));
+
 TEST_P(ThreadableLoaderTest, StartAndStop)
 {
 }
 
 TEST_P(ThreadableLoaderTest, CancelAfterStart)
 {
     InSequence s;
     EXPECT_CALL(checkpoint(), Call(1));
     createLoader();
     callCheckpoint(1);
@@ skipping 401 matching lines @@
     // test is not saying that didFailAccessControlCheck should be dispatched
     // synchronously, but is saying that even when a response is served
     // synchronously it should not lead to a crash.
     startLoader(KURL(KURL(), "about:blank"));
     callCheckpoint(2);
 }
 
 } // namespace
 
 } // namespace blink