Change BodyStreamBuffer to be FetchDataConsumerHandle-based and enable backpressure in Fetch API

Source/modules/fetch/DataConsumerHandleTestUtil.h

 // 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.
 
 #ifndef DataConsumerHandleTestUtil_h
 #define DataConsumerHandleTestUtil_h
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchDataConsumerHandle.h"
+#include "modules/fetch/FetchDataLoader.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebDataConsumerHandle.h"
 #include "public/platform/WebTraceLocation.h"
 #include "public/platform/WebWaitableEvent.h"
 #include "wtf/Locker.h"
 
@@ skipping 181 matching lines @@
             m_reader = nullptr;
             readingThread()->postTask(FROM_HERE, new Task(threadSafeBind(&Self::signalDone, this)));
         }
         void didGetReadable() override
         {
             ASSERT_NOT_REACHED();
         }
 
         OwnPtr<WebDataConsumerHandle> m_handle;
     };
+
+    class MockFetchDataLoaderClient : public GarbageCollectedFinalized<MockFetchDataLoaderClient>, public FetchDataLoader::Client {
+        USING_GARBAGE_COLLECTED_MIXIN(MockFetchDataLoaderClient);
+    public:
+        static ::testing::StrictMock<MockFetchDataLoaderClient>* create() { return new ::testing::StrictMock<MockFetchDataLoaderClient>; }
+
+        DEFINE_INLINE_VIRTUAL_TRACE()
+        {
+            FetchDataLoader::Client::trace(visitor);
+        }
+
+        MOCK_METHOD1(didFetchDataLoadedBlobHandleMock, void(RefPtr<BlobDataHandle>));
+        MOCK_METHOD1(didFetchDataLoadedArrayBufferMock, void(RefPtr<DOMArrayBuffer>));
+        MOCK_METHOD1(didFetchDataLoadedString, void(const String&));
+        MOCK_METHOD0(didFetchDataLoadFailed, void());
+
+        // In mock methods we use RefPtr<> rather than PassRefPtr<>.
+        void didFetchDataLoadedArrayBuffer(PassRefPtr<DOMArrayBuffer> arrayBuffer) override
+        {
+            didFetchDataLoadedArrayBufferMock(arrayBuffer);
+        }
+        void didFetchDataLoadedBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle) override
+        {
+            didFetchDataLoadedBlobHandleMock(blobDataHandle);
+        }
+    };
+
+    // From https://codereview.chromium.org/1195563002/
+
+    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;
+    };
+
+    // ReplayingHandle stores commands via |add| and replays the stored commends when read.
+    class ReplayingHandle final : public WebDataConsumerHandle {
+    public:
+        class Context;
+        class ReaderImpl;
+
+        ReplayingHandle();
+        ~ReplayingHandle();
+        Reader* obtainReaderInternal(Client*) override;
+
+        // 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&);
+
+        Context* context() { return m_context.get(); };
+
+    private:
+        RefPtr<Context> m_context;
+    };
+
 };
 
 } // namespace blink
 
 #endif // DataConsumerHandleTestUtil_h