Add FetchDataConsumerHandle and utility functions/classes

Source/modules/fetch/CompositeDataConsumerHandleTest.cpp

Index: Source/modules/fetch/CompositeDataConsumerHandleTest.cpp
diff --git a/Source/modules/fetch/CompositeDataConsumerHandleTest.cpp b/Source/modules/fetch/CompositeDataConsumerHandleTest.cpp
index 1b704070d2924550a7719bda7c3259fe90cf7d6e..52c52ee346e2a5652bc61e8f0394fe41616b6fc1 100644
--- a/Source/modules/fetch/CompositeDataConsumerHandleTest.cpp
+++ b/Source/modules/fetch/CompositeDataConsumerHandleTest.cpp
@@ -5,6 +5,7 @@
 #include "config.h"
 #include "modules/fetch/CompositeDataConsumerHandle.h"
 
+#include "modules/fetch/DataConsumerHandleUtilTest.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/heap/Handle.h"
@@ -21,124 +22,6 @@ namespace blink {
 
 namespace {
 
-using Result = WebDataConsumerHandle::Result;
-using Flags = WebDataConsumerHandle::Flags;
-using ::testing::InSequence;
-using ::testing::Return;
-using ::testing::StrictMock;
-using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
-
-const Result kShouldWait = WebDataConsumerHandle::ShouldWait;
-const Result kDone = WebDataConsumerHandle::Done;
-const Result kOk = WebDataConsumerHandle::Ok;
-const Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
-const Flags kNone = WebDataConsumerHandle::FlagNone;
-
-class NoopClient final : public WebDataConsumerHandle::Client {
-public:
-    void didGetReadable() override { }
-};
-
-class MockReader : public WebDataConsumerHandle::Reader {
-public:
-    static PassOwnPtr<StrictMock<MockReader>> create() { return adoptPtr(new StrictMock<MockReader>); }
-
-    MOCK_METHOD4(read, Result(void*, size_t, Flags, size_t*));
-    MOCK_METHOD3(beginRead, Result(const void**, Flags, size_t*));
-    MOCK_METHOD1(endRead, Result(size_t));
-};
-
-class MockHandle : public WebDataConsumerHandle {
-public:
-    static PassOwnPtr<StrictMock<MockHandle>> create() { return adoptPtr(new StrictMock<MockHandle>); }
-
-    MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
-};
-
-class ThreadingTestBase : public ThreadSafeRefCounted<ThreadingTestBase> {
-public:
-    class Context : public ThreadSafeRefCounted<Context> {
-    public:
-        static PassRefPtr<Context> create() { return adoptRef(new Context); }
-        void recordAttach(const String& handle)
-        {
-            MutexLocker locker(m_loggingMutex);
-            m_result.append("A reader is attached to " + handle + " on " + currentThreadName() + ".\n");
-        }
-        void recordDetach(const String& handle)
-        {
-            MutexLocker locker(m_loggingMutex);
-            m_result.append("A reader is detached from " + handle + " on " + currentThreadName() + ".\n");
-        }
-
-        const String& result()
-        {
-            MutexLocker locker(m_loggingMutex);
-            return m_result;
-        }
-        WebThread* readingThread() { return m_readingThread.get(); }
-        WebThread* updatingThread() { return m_updatingThread.get(); }
-
-    private:
-        Context()
-            : m_readingThread(adoptPtr(Platform::current()->createThread("reading thread")))
-            , m_updatingThread(adoptPtr(Platform::current()->createThread("updating thread")))
-        {
-        }
-        String currentThreadName()
-        {
-            if (m_readingThread->isCurrentThread())
-                return "the reading thread";
-            if (m_updatingThread->isCurrentThread())
-                return "the updating thread";
-            return "an unknown thread";
-        }
-
-        OwnPtr<WebThread> m_readingThread;
-        OwnPtr<WebThread> m_updatingThread;
-        Mutex m_loggingMutex;
-        String m_result;
-    };
-
-    class ReaderImpl final : public WebDataConsumerHandle::Reader {
-    public:
-        ReaderImpl(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context)
-        {
-            m_context->recordAttach(m_name.isolatedCopy());
-        }
-        ~ReaderImpl() override { m_context->recordDetach(m_name.isolatedCopy()); }
-        Result read(void*, size_t, Flags, size_t*) override { return kShouldWait; }
-        Result beginRead(const void**, Flags, size_t*) override { return kShouldWait; }
-        Result endRead(size_t) override { return kUnexpectedError; }
-
-    private:
-        const String m_name;
-        RefPtr<Context> m_context;
-    };
-    class DataConsumerHandle final : public WebDataConsumerHandle {
-    public:
-        DataConsumerHandle(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context) { }
-
-    private:
-        Reader* obtainReaderInternal(Client*) { return new ReaderImpl(m_name, m_context); }
-        const String m_name;
-        RefPtr<Context> m_context;
-    };
-
-    void resetReader() { m_reader = nullptr; }
-    void signalDone() { m_waitableEvent->signal(); }
-    const String& result() { return m_context->result(); }
-    WebThread* readingThread() { return m_context->readingThread(); }
-    WebThread* updatingThread() { return m_context->updatingThread(); }
-
-protected:
-    RefPtr<Context> m_context;
-    OwnPtr<CompositeDataConsumerHandle> m_handle;
-    OwnPtr<WebDataConsumerHandle::Reader> m_reader;
-    OwnPtr<WebWaitableEvent> m_waitableEvent;
-    NoopClient m_client;
-};
-
 class ThreadingRegistrationTest : public ThreadingTestBase {
 public:
     using Self = ThreadingRegistrationTest;
@@ -165,6 +48,8 @@ private:
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::resetReader, this)));
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
     }
+
+    OwnPtr<CompositeDataConsumerHandle> m_handle;
 };
 
 class ThreadingRegistrationDeleteHandleTest : public ThreadingTestBase {
@@ -194,6 +79,8 @@ private:
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::resetReader, this)));
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
     }
+
+    OwnPtr<CompositeDataConsumerHandle> m_handle;
 };
 
 class ThreadingRegistrationDeleteReaderTest : public ThreadingTestBase {
@@ -223,6 +110,8 @@ private:
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::resetReader, this)));
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
     }
+
+    OwnPtr<CompositeDataConsumerHandle> m_handle;
 };
 
 class ThreadingUpdatingReaderWhileUpdatingTest : public ThreadingTestBase {
@@ -263,6 +152,7 @@ private:
         m_reader = m_handle->obtainReader(&m_client);
     }
 
+    OwnPtr<CompositeDataConsumerHandle> m_handle;
     OwnPtr<WebWaitableEvent> m_updateEvent;
 };
 
@@ -293,87 +183,10 @@ private:
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::resetReader, this)));
         readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
     }
-};
 
-class ThreadingDoneHandleNotificationTest : public ThreadingTestBase, public WebDataConsumerHandle::Client {
-public:
-    using Self = ThreadingDoneHandleNotificationTest;
-    void run()
-    {
-        m_context = Context::create();
-        m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
-        m_handle = CompositeDataConsumerHandle::create(CompositeDataConsumerHandle::createDoneHandle());
-
-        readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::obtainReader, this)));
-
-        m_waitableEvent->wait();
-    }
-
-private:
-    void obtainReader()
-    {
-        m_reader = m_handle->obtainReader(this);
-    }
-    void didGetReadable() override
-    {
-        readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::resetReader, this)));
-        readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
-    }
-};
-
-class ThreadingDoneHandleNoNotificationTest : public ThreadingTestBase, public WebDataConsumerHandle::Client {
-public:
-    using Self = ThreadingDoneHandleNoNotificationTest;
-    void run()
-    {
-        m_context = Context::create();
-        m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
-        m_handle = CompositeDataConsumerHandle::create(CompositeDataConsumerHandle::createDoneHandle());
-
-        readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::obtainReader, this)));
-
-        m_waitableEvent->wait();
-    }
-
-private:
-    void obtainReader()
-    {
-        m_reader = m_handle->obtainReader(this);
-        m_reader = nullptr;
-        readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
-    }
-    void didGetReadable() override
-    {
-        ASSERT_NOT_REACHED();
-    }
+    OwnPtr<CompositeDataConsumerHandle> m_handle;
 };
 
-TEST(CompositeDataConsumerHandleTest, CreateWaitingHandle)
-{
-    char buffer[20];
-    const void* p = nullptr;
-    size_t size = 0;
-    OwnPtr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::createWaitingHandle();
-    OwnPtr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-
-    EXPECT_EQ(kShouldWait, reader->read(buffer, sizeof(buffer), kNone, &size));
-    EXPECT_EQ(kShouldWait, reader->beginRead(&p, kNone, &size));
-    EXPECT_EQ(kUnexpectedError, reader->endRead(99));
-}
-
-TEST(CompositeDataConsumerHandleTest, CreateDoneHandle)
-{
-    char buffer[20];
-    const void* p = nullptr;
-    size_t size = 0;
-    OwnPtr<WebDataConsumerHandle> handle = CompositeDataConsumerHandle::createDoneHandle();
-    OwnPtr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
-
-    EXPECT_EQ(kDone, reader->read(buffer, sizeof(buffer), kNone, &size));
-    EXPECT_EQ(kDone, reader->beginRead(&p, kNone, &size));
-    EXPECT_EQ(kUnexpectedError, reader->endRead(99));
-}
-
 TEST(CompositeDataConsumerHandleTest, Read)
 {
     char buffer[20];
@@ -581,16 +394,16 @@ TEST(CompositeDataConsumerHandleTest, UpdateTwiceAtOnce)
 
 TEST(CompositeDataConsumerHandleTest, DoneHandleNotification)
 {
-    ThreadingDoneHandleNotificationTest test;
+    ThreadingHandleNotificationTest test;
     // Test this function returns.
-    test.run();
+    test.run(CompositeDataConsumerHandle::create(createDoneHandle()));
 }
 
 TEST(CompositeDataConsumerHandleTest, DoneHandleNoNotification)
 {
-    ThreadingDoneHandleNoNotificationTest test;
+    ThreadingHandleNoNotificationTest test;
     // Test this function doesn't crash.
-    test.run();
+    test.run(CompositeDataConsumerHandle::create(createDoneHandle()));
 }
 
 } // namespace