Fetch DataConsumerHandle test cleanup

Source/modules/fetch/DataConsumerTeeTest.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 "modules/fetch/DataConsumerTee.h"
 
-#include "bindings/core/v8/ScriptState.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/testing/NullExecutionContext.h"
-#include "gin/public/isolate_holder.h"
+#include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "public/platform/WebWaitableEvent.h"
 #include "wtf/Deque.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 
 #include <gtest/gtest.h>
 #include <string.h>
 #include <v8.h>
 
 namespace blink {
 namespace {
 
 using Result = WebDataConsumerHandle::Result;
+using Thread = DataConsumerHandleTestUtil::Thread;
 const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
 const Result kOk = WebDataConsumerHandle::Ok;
 const Result kShouldWait = WebDataConsumerHandle::ShouldWait;
 const Result kDone = WebDataConsumerHandle::Done;
 const Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
 
 class Command final {
 public:
     enum Name {
         Data,
@@ skipping 217 matching lines @@
     {
         m_context->add(command);
     }
 
     Context* context() { return m_context.get(); };
 
 private:
     RefPtr<Context> m_context;
 };
 
-class TestingThread final {
-public:
-    explicit TestingThread(const char* name)
-        : m_thread(WebThreadSupportingGC::create(name))
-        , m_waitableEvent(adoptPtr(Platform::current()->createWaitableEvent()))
-    {
-        m_thread->postTask(FROM_HERE, new Task(threadSafeBind(&TestingThread::initialize, AllowCrossThreadAccess(this))));
-        m_waitableEvent->wait();
-    }
-
-    ~TestingThread()
-    {
-        m_thread->postTask(FROM_HERE, new Task(threadSafeBind(&TestingThread::shutdown, AllowCrossThreadAccess(this))));
-        m_waitableEvent->wait();
-    }
-
-    WebThreadSupportingGC* thread() { return m_thread.get(); }
-    ExecutionContext* executionContext() { return m_executionContext.get(); }
-    ScriptState* scriptState() { return m_scriptState.get(); }
-    v8::Isolate* isolate() { return m_isolateHolder->isolate(); }
-
-private:
-    void initialize()
-    {
-        m_isolateHolder = adoptPtr(new gin::IsolateHolder());
-        m_thread->initialize();
-        isolate()->Enter();
-        v8::HandleScope handleScope(isolate());
-        v8::Local<v8::Context> context = v8::Context::New(isolate());
-        m_scriptState = ScriptState::create(context, DOMWrapperWorld::create(isolate()));
-        m_executionContext = adoptRefWillBeNoop(new NullExecutionContext());
-        m_waitableEvent->signal();
-    }
-
-    void shutdown()
-    {
-        m_executionContext = nullptr;
-        m_scriptState = nullptr;
-        isolate()->Exit();
-        m_thread->shutdown();
-        m_isolateHolder = nullptr;
-        m_waitableEvent->signal();
-    }
-
-    OwnPtr<WebThreadSupportingGC> m_thread;
-    OwnPtr<WebWaitableEvent> m_waitableEvent;
-    RefPtrWillBePersistent<NullExecutionContext> m_executionContext;
-    OwnPtr<gin::IsolateHolder> m_isolateHolder;
-    RefPtr<ScriptState> m_scriptState;
-};
-
 class HandleReader : public WebDataConsumerHandle::Client {
 public:
     HandleReader() : m_finalResult(kOk) { }
 
     // Need to wait for the event signal after this function is called.
     void start(PassOwnPtr<WebDataConsumerHandle> handle)
     {
-        m_thread = adoptPtr(new TestingThread("reading thread"));
+        m_thread = adoptPtr(new Thread("reading thread"));
         m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
         m_thread->thread()->postTask(FROM_HERE, new Task(threadSafeBind(&HandleReader::obtainReader, AllowCrossThreadAccess(this), handle)));
     }
 
     void didGetReadable() override
     {
         Result r = kOk;
         char buffer[3];
         while (true) {
             size_t size;
@@ skipping 14 matching lines @@
     // These should be accessed after the thread joins.
     const String& readString() const { return m_readString; }
     Result finalResult() const { return m_finalResult; }
 
 private:
     void obtainReader(PassOwnPtr<WebDataConsumerHandle> handle)
     {
         m_reader = handle->obtainReader(this);
     }
 
-    OwnPtr<TestingThread> m_thread;
+    OwnPtr<Thread> m_thread;
     OwnPtr<WebDataConsumerHandle::Reader> m_reader;
     String m_readString;
     Result m_finalResult;
     OwnPtr<WebWaitableEvent> m_waitableEvent;
 };
 
 class HandleTwoPhaseReader : public WebDataConsumerHandle::Client {
 public:
     HandleTwoPhaseReader() : m_finalResult(kOk) { }
 
     // Need to wait for the event signal after this function is called.
     void start(PassOwnPtr<WebDataConsumerHandle> handle)
     {
-        m_thread = adoptPtr(new TestingThread("reading thread"));
+        m_thread = adoptPtr(new Thread("reading thread"));
         m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
         m_thread->thread()->postTask(FROM_HERE, new Task(threadSafeBind(&HandleTwoPhaseReader::obtainReader, AllowCrossThreadAccess(this), handle)));
     }
 
     void didGetReadable() override
     {
         Result r = kOk;
         while (true) {
             const void* buffer = nullptr;
             size_t size;
@@ skipping 17 matching lines @@
     // These should be accessed after the thread joins.
     const String& readString() const { return m_readString; }
     Result finalResult() const { return m_finalResult; }
 
 private:
     void obtainReader(PassOwnPtr<WebDataConsumerHandle> handle)
     {
         m_reader = handle->obtainReader(this);
     }
 
-    OwnPtr<TestingThread> m_thread;
+    OwnPtr<Thread> m_thread;
     OwnPtr<WebDataConsumerHandle::Reader> m_reader;
     String m_readString;
     Result m_finalResult;
     OwnPtr<WebWaitableEvent> m_waitableEvent;
 };
 
 class TeeCreationThread {
 public:
     void run(PassOwnPtr<WebDataConsumerHandle> src, OwnPtr<WebDataConsumerHandle>* dest1, OwnPtr<WebDataConsumerHandle>* dest2)
     {
-        m_thread = adoptPtr(new TestingThread("src thread"));
+        m_thread = adoptPtr(new Thread("src thread", Thread::WithExecutionContext));
         m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
         m_thread->thread()->postTask(FROM_HERE, new Task(threadSafeBind(&TeeCreationThread::runInternal, AllowCrossThreadAccess(this), src, AllowCrossThreadAccess(dest1), AllowCrossThreadAccess(dest2))));
         m_waitableEvent->wait();
     }
 
-    TestingThread* thread() { return m_thread.get(); }
+    Thread* thread() { return m_thread.get(); }
 
 private:
     void runInternal(PassOwnPtr<WebDataConsumerHandle> src, OwnPtr<WebDataConsumerHandle>* dest1, OwnPtr<WebDataConsumerHandle>* dest2)
     {
         DataConsumerTee::create(m_thread->executionContext(), src, dest1, dest2);
         m_waitableEvent->signal();
     }
 
-    OwnPtr<TestingThread> m_thread;
+    OwnPtr<Thread> m_thread;
     OwnPtr<WebWaitableEvent> m_waitableEvent;
 };
 
 TEST(DataConsumerTeeTest, CreateDone)
 {
     OwnPtr<Handle> src(adoptPtr(new Handle));
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Done));
 
@@ skipping 103 matching lines @@
     r1.start(dest1.release());
     r2.start(dest2.release());
 
     r1.waitableEvent()->wait();
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kUnexpectedError, r1.finalResult());
     EXPECT_EQ(kUnexpectedError, r2.finalResult());
 }
 
-void postStop(TestingThread* thread)
+void postStop(Thread* thread)
 {
     thread->executionContext()->stopActiveDOMObjects();
 }
 
 TEST(DataConsumerTeeTest, StopSource)
 {
     OwnPtr<Handle> src(adoptPtr(new Handle));
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
@@ skipping 121 matching lines @@
     dest1 = nullptr;
     dest2 = nullptr;
 
     // Collect garbage to finalize the source reader.
     Heap::collectAllGarbage();
     context->detached()->wait();
 }
 
 } // namespace
 } // namespace blink