Use BytesConsumer in BodyStreamBuffer

third_party/WebKit/Source/modules/fetch/BodyStreamBufferTest.cpp

 // Copyright 2014 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 "modules/fetch/BodyStreamBuffer.h"
 
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/html/FormData.h"
+#include "modules/fetch/BytesConsumerTestUtil.h"
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "modules/fetch/FetchBlobDataConsumerHandle.h"
 #include "modules/fetch/FetchFormDataConsumerHandle.h"
 #include "platform/blob/BlobData.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/network/EncodedFormData.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
@@ skipping 52 matching lines @@
 };
 
 TEST_F(BodyStreamBufferTest, Tee)
 {
     V8TestingScope scope;
     Checkpoint checkpoint;
     MockFetchDataLoaderClient* client1 = MockFetchDataLoaderClient::create();
     MockFetchDataLoaderClient* client2 = MockFetchDataLoaderClient::create();
 
     InSequence s;
+    EXPECT_CALL(checkpoint, Call(0));
+    EXPECT_CALL(*client1, didFetchDataLoadedString(String("hello, world")));

[hiroshige, 2016/09/07 09:25:54]

What causes this behavior change?

[yhirano, 2016/09/08 01:41:05]

Unlike DataConsuerTee, BytesConsumerTee start enqueuing data synchronously. If
the loader starts reading synchronously as FetchDataLoader, the timing will
change.

     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*client1, didFetchDataLoadedString(String("hello, world")));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*client2, didFetchDataLoadedString(String("hello, world")));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(checkpoint, Call(4));
 
     std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> handle = DataConsumerHandleTestUtil::ReplayingHandle::create();
     handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::Command::Data, "hello, "));
     handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::Command::Data, "world"));
     handle->add(DataConsumerHandleTestUtil::Command(DataConsumerHandleTestUtil::Command::Done));
     BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), createFetchDataConsumerHandleFromWebHandle(std::move(handle)));
 
     BodyStreamBuffer* new1;
     BodyStreamBuffer* new2;
     buffer->tee(&new1, &new2);
 
     EXPECT_TRUE(buffer->isStreamLocked());
     EXPECT_TRUE(buffer->isStreamDisturbed());
     EXPECT_FALSE(buffer->hasPendingActivity());
 
+    checkpoint.Call(0);
     new1->startLoading(FetchDataLoader::createLoaderAsString(), client1);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
 
     new2->startLoading(FetchDataLoader::createLoaderAsString(), client2);
     checkpoint.Call(3);
     testing::runPendingTasks();
     checkpoint.Call(4);
 }
@@ skipping 57 matching lines @@
     V8TestingScope scope;
     std::unique_ptr<BlobData> data = BlobData::create();
     data->appendText("hello", false);
     auto size = data->length();
     RefPtr<BlobDataHandle> blobDataHandle = BlobDataHandle::create(std::move(data), size);
     BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), FetchBlobDataConsumerHandle::create(scope.getExecutionContext(), blobDataHandle, new FakeLoaderFactory));
 
     EXPECT_FALSE(buffer->isStreamLocked());
     EXPECT_FALSE(buffer->isStreamDisturbed());
     EXPECT_FALSE(buffer->hasPendingActivity());
-    RefPtr<BlobDataHandle> outputBlobDataHandle = buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize);
+    RefPtr<BlobDataHandle> outputBlobDataHandle = buffer->drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::AllowBlobWithInvalidSize);
 
     EXPECT_TRUE(buffer->isStreamLocked());
     EXPECT_TRUE(buffer->isStreamDisturbed());
     EXPECT_FALSE(buffer->hasPendingActivity());
     EXPECT_EQ(blobDataHandle, outputBlobDataHandle);
 }
 
 TEST_F(BodyStreamBufferTest, DrainAsBlobDataHandleReturnsNull)
 {
     V8TestingScope scope;
     // This handle is not drainable.
     std::unique_ptr<FetchDataConsumerHandle> handle = createFetchDataConsumerHandleFromWebHandle(createWaitingDataConsumerHandle());
     BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), std::move(handle));
 
     EXPECT_FALSE(buffer->isStreamLocked());
     EXPECT_FALSE(buffer->isStreamDisturbed());
     EXPECT_FALSE(buffer->hasPendingActivity());
 
-    EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize));
+    EXPECT_FALSE(buffer->drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::AllowBlobWithInvalidSize));
 
     EXPECT_FALSE(buffer->isStreamLocked());
     EXPECT_FALSE(buffer->isStreamDisturbed());
     EXPECT_FALSE(buffer->hasPendingActivity());
 }
 
 TEST_F(BodyStreamBufferTest, DrainAsBlobFromBufferMadeFromBufferMadeFromStream)
 {
     V8TestingScope scope;
     ScriptValue stream = evalWithPrintingError(scope.getScriptState(), "new ReadableStream()");
     BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), stream);
 
     EXPECT_FALSE(buffer->hasPendingActivity());
     EXPECT_FALSE(buffer->isStreamLocked());
     EXPECT_FALSE(buffer->isStreamDisturbed());
     EXPECT_TRUE(buffer->isStreamReadable());
 
-    EXPECT_FALSE(buffer->drainAsBlobDataHandle(FetchDataConsumerHandle::Reader::AllowBlobWithInvalidSize));
+    EXPECT_FALSE(buffer->drainAsBlobDataHandle(BytesConsumer::BlobSizePolicy::AllowBlobWithInvalidSize));
 
     EXPECT_FALSE(buffer->hasPendingActivity());
     EXPECT_FALSE(buffer->isStreamLocked());
     EXPECT_FALSE(buffer->isStreamDisturbed());
     EXPECT_TRUE(buffer->isStreamReadable());
 }
 
 TEST_F(BodyStreamBufferTest, DrainAsFormData)
 {
     V8TestingScope scope;
@@ skipping 227 matching lines @@
     handle->add(Command(Command::Done));
     Persistent<BodyStreamBuffer> buffer = new BodyStreamBuffer(scope.getScriptState(), createFetchDataConsumerHandleFromWebHandle(std::move(handle)));
     buffer->startLoading(FetchDataLoader::createLoaderAsString(), client);
 
     ThreadHeap::collectAllGarbage();
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
 }
 
-// TODO(hiroshige): Merge this class into MockFetchDataConsumerHandle.
-class MockFetchDataConsumerHandleWithMockDestructor : public DataConsumerHandleTestUtil::MockFetchDataConsumerHandle {
-public:
-    static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandleWithMockDestructor>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandleWithMockDestructor>); }
-
-    ~MockFetchDataConsumerHandleWithMockDestructor() override
-    {
-        destruct();
-    }
-
-    MOCK_METHOD0(destruct, void());
-};
-
-TEST_F(BodyStreamBufferTest, SourceHandleAndReaderShouldBeDestructedWhenCanceled)
+TEST_F(BodyStreamBufferTest, SourceShouldBeCanceledWhenCanceled)
 {
     V8TestingScope scope;
-    using MockHandle = MockFetchDataConsumerHandleWithMockDestructor;
-    using MockReader = DataConsumerHandleTestUtil::MockFetchDataConsumerReader;
-    std::unique_ptr<MockHandle> handle = MockHandle::create();
-    // |reader| will be adopted by |obtainFetchDataReader|.
-    MockReader* reader = MockReader::create().release();
+    BytesConsumerTestUtil::ReplayingBytesConsumer* consumer = new BytesConsumerTestUtil::ReplayingBytesConsumer(scope.getExecutionContext());
 
-    Checkpoint checkpoint;
-    InSequence s;
-
-    EXPECT_CALL(*handle, obtainFetchDataReader(_)).WillOnce(Return(ByMove(WTF::wrapUnique(reader))));
-    EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*reader, destruct());
-    EXPECT_CALL(*handle, destruct());
-    EXPECT_CALL(checkpoint, Call(2));
-
-    BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), std::move(handle));
-    checkpoint.Call(1);
+    BodyStreamBuffer* buffer = new BodyStreamBuffer(scope.getScriptState(), consumer);
     ScriptValue reason(scope.getScriptState(), v8String(scope.getScriptState()->isolate(), "reason"));
+    EXPECT_FALSE(consumer->isCancelled());
     buffer->cancel(scope.getScriptState(), reason);
-    checkpoint.Call(2);
+    EXPECT_TRUE(consumer->isCancelled());
 }
 
 } // namespace
 
 } // namespace blink