Reland of [Fetch API] Start reading blob only when the reader wants to read contents.

third_party/WebKit/Source/modules/fetch/FetchBlobDataConsumerHandleTest.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 "modules/fetch/FetchBlobDataConsumerHandle.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/MockThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
@@ skipping 94 matching lines @@
         Return(loader.get())));
     EXPECT_CALL(*loader, start(_)).WillOnce(SaveArg<0>(&request));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, cancel());
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     testing::runPendingTasks();
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
 
     EXPECT_TRUE(request.url().getString().startsWith("blob:"));
     EXPECT_TRUE(request.useStreamOnResponse());
 
     EXPECT_EQ(ConsiderPreflight, options.preflightPolicy);
     EXPECT_EQ(DenyCrossOriginRequests, options.crossOriginRequestPolicy);
     EXPECT_EQ(DoNotEnforceContentSecurityPolicy, options.contentSecurityPolicyEnforcement);
 
     EXPECT_EQ(DoNotBufferData, resourceLoaderOptions.dataBufferingPolicy);
     EXPECT_EQ(DoNotAllowStoredCredentials, resourceLoaderOptions.allowCredentials);
     EXPECT_EQ(ClientDidNotRequestCredentials, resourceLoaderOptions.credentialsRequested);
     EXPECT_EQ(CheckContentSecurityPolicy, resourceLoaderOptions.contentSecurityPolicyOption);
     EXPECT_EQ(DocumentContext, resourceLoaderOptions.requestInitiatorContext);
     EXPECT_EQ(RequestAsynchronously, resourceLoaderOptions.synchronousPolicy);
     EXPECT_EQ(NotCORSEnabled, resourceLoaderOptions.corsEnabled);
 }
 
+TEST_F(FetchBlobDataConsumerHandleTest, ZeroByteReadDoesNotCreateLoader)
+{
+    auto factory = new StrictMock<MockLoaderFactory>;
+    Checkpoint checkpoint;
+
+    InSequence s;
+    EXPECT_CALL(checkpoint, Call(1));
+    EXPECT_CALL(checkpoint, Call(2));
+
+    RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
+    std::unique_ptr<WebDataConsumerHandle> handle
+        = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
+    testing::runPendingTasks();
+
+    size_t size = 0;
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size));
+    checkpoint.Call(1);
+    testing::runPendingTasks();
+    checkpoint.Call(2);
+}
+
 TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenStopped)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
     EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     testing::runPendingTasks();
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     document().stopActiveDOMObjects();
     checkpoint.Call(3);
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenDestinationDetached)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
     EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*loader, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     std::unique_ptr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     testing::runPendingTasks();
 
+    char buffer[1];
     size_t size = 0;
-    reader->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, reader->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     handle = nullptr;
     reader = nullptr;
     checkpoint.Call(3);
     ThreadHeap::collectAllGarbage();
     checkpoint.Call(4);
 }
 
@@ skipping 16 matching lines @@
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didReceiveResponse(0, ResourceResponse(), std::move(src));
     HandleReaderRunner<HandleReader> runner(std::move(handle));
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("hello, world", toString(r->data()));
 }
 
@@ skipping 16 matching lines @@
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didReceiveResponse(0, ResourceResponse(), std::move(src));
     HandleReaderRunner<HandleTwoPhaseReader> runner(std::move(handle));
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("hello, world", toString(r->data()));
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, LoadErrorTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
     ThreadableLoaderClient* client = nullptr;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
     EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
     EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didFail(ResourceError());
     HandleReaderRunner<HandleReader> runner(std::move(handle));
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kUnexpectedError, r->result());
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, BodyLoadErrorTest)
@@ skipping 13 matching lines @@
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Error));
 
+    char buffer[1];
     size_t size = 0;
-    handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
+    ASSERT_EQ(kShouldWait, handle->obtainReader(nullptr)->read(buffer, sizeof(buffer), kNone, &size));
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didReceiveResponse(0, ResourceResponse(), std::move(src));
     HandleReaderRunner<HandleReader> runner(std::move(handle));
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kUnexpectedError, r->result());
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, DrainAsBlobDataHandle)
@@ skipping 71 matching lines @@
     std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
 
     const void* buffer;
     size_t available;
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     EXPECT_FALSE(reader->drainAsBlobDataHandle());
 }
 
 } // namespace
 } // namespace blink