Move Handle in TeeTest and MockFetchDataLoaderClient to TestUtil

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 "core/testing/DummyPageHolder.h"
 #include "core/testing/NullExecutionContext.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"

[yhirano, 2015/06/25 04:31:03]

-Deque
-Vector
-ThreadingPrimitives
-ThreadSafeRefCounted

[hiroshige, 2015/06/25 05:33:57]

Done.

 
 #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,
-        Done,
-        Error,
-        Wait,
-    };
-
-    Command(Name name) : m_name(name) { }
-    Command(Name name, const Vector<char>& body) : m_name(name), m_body(body) { }
-    Command(Name name, const char* body, size_t size) : m_name(name)
-    {
-        m_body.append(body, size);
-    }
-    Command(Name name, const char* body) : Command(name, body, strlen(body)) { }
-    Name name() const { return m_name; }
-    const Vector<char>& body() const { return m_body; }
-
-private:
-    const Name m_name;
-    Vector<char> m_body;
-};
-
-// Handle stores commands via |add| and replays the stored commends when read.
-class Handle final : public WebDataConsumerHandle {
-public:
-    class Context final : public ThreadSafeRefCounted<Context> {
-    public:
-        static PassRefPtr<Context> create() { return adoptRef(new Context); }
-
-        // This function cannot be called after creating a tee.
-        void add(const Command& command)
-        {
-            MutexLocker locker(m_mutex);
-            m_commands.append(command);
-        }
-
-        void attachReader(WebDataConsumerHandle::Client* client)
-        {
-            MutexLocker locker(m_mutex);
-            ASSERT(!m_readerThread);
-            ASSERT(!m_client);
-            m_readerThread = Platform::current()->currentThread();
-            m_client = client;
-
-            if (m_client && !(isEmpty() && m_result == kShouldWait))
-                notify();
-        }
-        void detachReader()
-        {
-            MutexLocker locker(m_mutex);
-            ASSERT(m_readerThread && m_readerThread->isCurrentThread());
-            m_readerThread = nullptr;
-            m_client = nullptr;
-            if (!m_isHandleAttached)
-                m_detached->signal();
-        }
-
-        void detachHandle()
-        {
-            MutexLocker locker(m_mutex);
-            m_isHandleAttached = false;
-            if (!m_readerThread)
-                m_detached->signal();
-        }
-
-        Result beginRead(const void** buffer, Flags, size_t* available)
-        {
-            MutexLocker locker(m_mutex);
-            *buffer = nullptr;
-            *available = 0;
-            if (isEmpty())
-                return m_result;
-
-            const Command& command = top();
-            Result result = Ok;
-            switch (command.name()) {
-            case Command::Data: {
-                auto& body = command.body();
-                *available = body.size() - offset();
-                *buffer = body.data() + offset();
-                result = Ok;
-                break;
-            }
-            case Command::Done:
-                m_result = result = Done;
-                consume(0);
-                break;
-            case Command::Wait:
-                consume(0);
-                result = ShouldWait;
-                notify();
-                break;
-            case Command::Error:
-                m_result = result = UnexpectedError;
-                consume(0);
-                break;
-            }
-            return result;
-        }
-        Result endRead(size_t readSize)
-        {
-            MutexLocker locker(m_mutex);
-            consume(readSize);
-            return Ok;
-        }
-
-        WebWaitableEvent* detached() { return m_detached.get(); }
-
-    private:
-        Context()
-            : m_offset(0)
-            , m_readerThread(nullptr)
-            , m_client(nullptr)
-            , m_result(ShouldWait)
-            , m_isHandleAttached(true)
-            , m_detached(adoptPtr(Platform::current()->createWaitableEvent()))
-        {
-        }
-
-        bool isEmpty() const { return m_commands.isEmpty(); }
-        const Command& top()
-        {
-            ASSERT(!isEmpty());
-            return m_commands.first();
-        }
-
-        void consume(size_t size)
-        {
-            ASSERT(!isEmpty());
-            ASSERT(size + m_offset <= top().body().size());
-            bool fullyConsumed = (size + m_offset >= top().body().size());
-            if (fullyConsumed) {
-                m_offset = 0;
-                m_commands.removeFirst();
-            } else {
-                m_offset += size;
-            }
-        }
-
-        size_t offset() const { return m_offset; }
-
-        void notify()
-        {
-            if (!m_client)
-                return;
-            ASSERT(m_readerThread);
-            m_readerThread->postTask(FROM_HERE, new Task(threadSafeBind(&Context::notifyInternal, this)));
-        }
-
-        void notifyInternal()
-        {
-            {
-                MutexLocker locker(m_mutex);
-                if (!m_client || !m_readerThread->isCurrentThread()) {
-                    // There is no client, or a new reader is attached.
-                    return;
-                }
-            }
-            // The reading thread is the current thread.
-            m_client->didGetReadable();
-        }
-
-        Deque<Command> m_commands;
-        size_t m_offset;
-        WebThread* m_readerThread;
-        Client* m_client;
-        Result m_result;
-        bool m_isHandleAttached;
-        Mutex m_mutex;
-        OwnPtr<WebWaitableEvent> m_detached;
-    };
-
-    class ReaderImpl final : public Reader {
-    public:
-        ReaderImpl(PassRefPtr<Context> context, Client* client)
-            : m_context(context)
-        {
-            m_context->attachReader(client);
-        }
-        ~ReaderImpl()
-        {
-            m_context->detachReader();
-        }
-
-        Result read(void* buffer, size_t size, Flags flags, size_t* readSize) override
-        {
-            const void* src = nullptr;
-            Result result = beginRead(&src, flags, readSize);
-            if (result != Ok)
-                return result;
-            *readSize = std::min(*readSize, size);
-            memcpy(buffer, src, *readSize);
-            return endRead(*readSize);
-        }
-        Result beginRead(const void** buffer, Flags flags, size_t* available) override
-        {
-            return m_context->beginRead(buffer, flags, available);
-        }
-        Result endRead(size_t readSize) override
-        {
-            return m_context->endRead(readSize);
-        }
-
-    private:
-        RefPtr<Context> m_context;
-    };
-
-    Handle() : m_context(Context::create()) { }
-    ~Handle()
-    {
-        m_context->detachHandle();
-    }
-
-    ReaderImpl* obtainReaderInternal(Client* client) override { return new ReaderImpl(m_context, client); }
-
-    // Add a command to this handle. This function must be called on the
-    // creator thread. This function must be called BEFORE any reader is
-    // obtained.
-    void add(const Command& command)
-    {
-        m_context->add(command);
-    }
-
-    Context* context() { return m_context.get(); };
-
-private:
-    RefPtr<Context> m_context;
-};
+using Command = DataConsumerHandleTestUtil::Command;
+using Handle = DataConsumerHandleTestUtil::ReplayingHandle;
 
 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 Thread("reading thread"));
         m_waitableEvent = adoptPtr(Platform::current()->createWaitableEvent());
@@ skipping 107 matching lines @@
         DataConsumerTee::create(m_thread->executionContext(), src, dest1, dest2);
         m_waitableEvent->signal();
     }
 
     OwnPtr<Thread> m_thread;
     OwnPtr<WebWaitableEvent> m_waitableEvent;
 };
 
 TEST(DataConsumerTeeTest, CreateDone)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Done));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
     ASSERT_TRUE(dest2);
 
     HandleReader r1, r2;
     r1.start(dest1.release());
     r2.start(dest2.release());
 
     r1.waitableEvent()->wait();
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kDone, r1.finalResult());
     EXPECT_EQ(String(), r1.readString());
 
     EXPECT_EQ(kDone, r2.finalResult());
     EXPECT_EQ(String(), r2.readString());
 }
 
 TEST(DataConsumerTeeTest, Read)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
 
@@ skipping 12 matching lines @@
 
     EXPECT_EQ(kDone, r1.finalResult());
     EXPECT_EQ("hello, world", r1.readString());
 
     EXPECT_EQ(kDone, r2.finalResult());
     EXPECT_EQ("hello, world", r2.readString());
 }
 
 TEST(DataConsumerTeeTest, TwoPhaseRead)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
@@ skipping 13 matching lines @@
 
     EXPECT_EQ(kDone, r1.finalResult());
     EXPECT_EQ("hello, world", r1.readString());
 
     EXPECT_EQ(kDone, r2.finalResult());
     EXPECT_EQ("hello, world", r2.readString());
 }
 
 TEST(DataConsumerTeeTest, Error)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Error));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
@@ skipping 10 matching lines @@
     EXPECT_EQ(kUnexpectedError, r2.finalResult());
 }
 
 void postStop(Thread* thread)
 {
     thread->executionContext()->stopActiveDOMObjects();
 }
 
 TEST(DataConsumerTeeTest, StopSource)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
     ASSERT_TRUE(dest2);
 
     HandleReader r1, r2;
     r1.start(dest1.release());
     r2.start(dest2.release());
 
     // We can pass a raw pointer because the subsequent |wait| calls ensure
     // t->thread() is alive.
     t->thread()->thread()->postTask(FROM_HERE, new Task(threadSafeBind(postStop, AllowCrossThreadAccess(t->thread()))));
 
     r1.waitableEvent()->wait();
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kUnexpectedError, r1.finalResult());
     EXPECT_EQ(kUnexpectedError, r2.finalResult());
 }
 
 TEST(DataConsumerTeeTest, DetachSource)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
     ASSERT_TRUE(dest2);
 
     HandleReader r1, r2;
     r1.start(dest1.release());
     r2.start(dest2.release());
 
     t = nullptr;
 
     r1.waitableEvent()->wait();
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kUnexpectedError, r1.finalResult());
     EXPECT_EQ(kUnexpectedError, r2.finalResult());
 }
 
 TEST(DataConsumerTeeTest, DetachSourceAfterReadingDone)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Done));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
@@ skipping 10 matching lines @@
 
     r2.start(dest2.release());
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kDone, r2.finalResult());
     EXPECT_EQ("hello, world", r2.readString());
 }
 
 TEST(DataConsumerTeeTest, DetachOneDestination)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Done));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
     ASSERT_TRUE(dest2);
 
     dest1 = nullptr;
 
     HandleReader r2;
     r2.start(dest2.release());
     r2.waitableEvent()->wait();
 
     EXPECT_EQ(kDone, r2.finalResult());
     EXPECT_EQ("hello, world", r2.readString());
 }
 
 TEST(DataConsumerTeeTest, DetachBothDestinationsShouldStopSourceReader)
 {
-    OwnPtr<Handle> src(adoptPtr(new Handle));
+    OwnPtr<Handle> src(Handle::create());
     RefPtr<Handle::Context> context(src->context());
     OwnPtr<WebDataConsumerHandle> dest1, dest2;
 
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
 
     OwnPtr<TeeCreationThread> t = adoptPtr(new TeeCreationThread());
     t->run(src.release(), &dest1, &dest2);
 
     ASSERT_TRUE(dest1);
     ASSERT_TRUE(dest2);
 
     dest1 = nullptr;
     dest2 = nullptr;
 
     // Collect garbage to finalize the source reader.
     Heap::collectAllGarbage();
     context->detached()->wait();
 }
 
 } // namespace
 } // namespace blink