Add unknown file size handling in ComplexFormDataBytesConsumer

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

 // Copyright 2016 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/FormDataBytesConsumer.h"
 
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/Document.h"
 #include "core/html/FormData.h"
@@ skipping 10 matching lines @@
 namespace blink {
 namespace {
 
 using Result = BytesConsumer::Result;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Return;
 using Checkpoint = ::testing::StrictMock<::testing::MockFunction<void(int)>>;
 using MockBytesConsumer = BytesConsumerTestUtil::MockBytesConsumer;
+using ReplayingBytesConsumer = BytesConsumerTestUtil::ReplayingBytesConsumer;
+using Command = BytesConsumerTestUtil::Command;
+
+BytesConsumer* createStubBytesConsumer(ExecutionContext* executionContext,
+                                       PassRefPtr<BlobDataHandle> handle) {
+  auto* consumer = new ReplayingBytesConsumer(executionContext);
+  consumer->add(Command(Command::Data, "type = "));
+  consumer->add(Command(Command::Data, handle->type().utf8().data()));
+  consumer->add(Command(Command::Done));
+  return consumer;
+}
+
+BytesConsumer* returnMockBytesConsumer(MockBytesConsumer* bytesConsumer,
+                                       ExecutionContext*,
+                                       PassRefPtr<BlobDataHandle>) {
+  return bytesConsumer;
+}
 
 String toString(const Vector<char>& v) {
   return String(v.data(), v.size());
 }
 
 PassRefPtr<EncodedFormData> complexFormData() {
   RefPtr<EncodedFormData> data = EncodedFormData::create();
 
   data->appendData("foo", 3);
   data->appendFileRange("/foo/bar/baz", 3, 4, 5);
   data->appendFileSystemURLRange(KURL(KURL(), "file:///foo/bar/baz"), 6, 7, 8);
   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->appendText("hello", false);
+  blobData->setContentType("text/plain");
   auto size = blobData->length();
   RefPtr<BlobDataHandle> blobDataHandle =
       BlobDataHandle::create(std::move(blobData), size);
   data->appendBlob(blobDataHandle->uuid(), blobDataHandle);
   Vector<char> boundary;
   boundary.append("\0", 1);
   data->setBoundary(boundary);
   return data.release();
 }
 
@@ skipping 69 matching lines @@
 
   auto result = (new BytesConsumerTestUtil::TwoPhaseReader(
                      new FormDataBytesConsumer(getDocument(), data)))
                     ->run();
   EXPECT_EQ(Result::Done, result.first);
   EXPECT_EQ("foohoge", toString(result.second));
 }
 
 TEST_F(FormDataBytesConsumerTest, TwoPhaseReadFromComplexFormData) {
   RefPtr<EncodedFormData> data = complexFormData();
-  MockBytesConsumer* underlying = MockBytesConsumer::create();
-  BytesConsumer* consumer =
-      FormDataBytesConsumer::createForTesting(getDocument(), data, underlying);
-  Checkpoint checkpoint;
+  BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
+      getDocument(), data, WTF::bind(createStubBytesConsumer));
 
-  const char* buffer = nullptr;
-  size_t available = 0;
+  auto result = (new BytesConsumerTestUtil::TwoPhaseReader(consumer))->run();
 
-  InSequence s;
-  EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(*underlying, beginRead(&buffer, &available))
-      .WillOnce(Return(Result::Ok));
-  EXPECT_CALL(checkpoint, Call(2));
-  EXPECT_CALL(*underlying, endRead(0)).WillOnce(Return(Result::Ok));
-  EXPECT_CALL(checkpoint, Call(3));
+  ASSERT_EQ(Result::Done, result.first);
+  String expected =
+      "foo"
+      "type = application/octet-stream"
+      "type = application/octet-stream"
+      "type = text/plain";
 
-  checkpoint.Call(1);
-  ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
-  checkpoint.Call(2);
-  EXPECT_EQ(Result::Ok, consumer->endRead(0));
-  checkpoint.Call(3);
+  EXPECT_EQ(expected, toString(result.second));
 }
 
 TEST_F(FormDataBytesConsumerTest, EndReadCanReturnDone) {
   BytesConsumer* consumer = new FormDataBytesConsumer("hello, world");
   const char* buffer = nullptr;
   size_t available = 0;
   ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
   ASSERT_EQ(12u, available);
   EXPECT_EQ("hello, world", String(buffer, available));
   EXPECT_EQ(BytesConsumer::PublicState::ReadableOrWaiting,
@@ skipping 50 matching lines @@
   size_t available = 0;
   EXPECT_EQ(Result::Done, consumer->beginRead(&buffer, &available));
   EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
 }
 
 TEST_F(FormDataBytesConsumerTest, DrainAsBlobDataHandleFromComplexFormData) {
   RefPtr<EncodedFormData> inputFormData = complexFormData();
 
   BytesConsumer* consumer =
       new FormDataBytesConsumer(getDocument(), inputFormData);
-  RefPtr<BlobDataHandle> blobDataHandle = consumer->drainAsBlobDataHandle();
-  ASSERT_TRUE(blobDataHandle);
+  EXPECT_EQ(nullptr, consumer->drainAsBlobDataHandle());
+  EXPECT_EQ(BytesConsumer::PublicState::ReadableOrWaiting,
+            consumer->getPublicState());
 
-  EXPECT_FALSE(consumer->drainAsFormData());
+  EXPECT_TRUE(consumer->drainAsFormData());
+  EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
   const char* buffer = nullptr;
   size_t available = 0;
   EXPECT_EQ(Result::Done, consumer->beginRead(&buffer, &available));
   EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
 }
 
 TEST_F(FormDataBytesConsumerTest, DrainAsFormDataFromString) {
   BytesConsumer* consumer = new FormDataBytesConsumer("hello, world");
   RefPtr<EncodedFormData> formData = consumer->drainAsFormData();
   ASSERT_TRUE(formData);
@@ skipping 36 matching lines @@
   EXPECT_EQ(Result::Done, consumer->beginRead(&buffer, &available));
   EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
 }
 
 TEST_F(FormDataBytesConsumerTest, DrainAsFormDataFromComplexFormData) {
   RefPtr<EncodedFormData> inputFormData = complexFormData();
 
   BytesConsumer* consumer =
       new FormDataBytesConsumer(getDocument(), inputFormData);
   EXPECT_EQ(inputFormData, consumer->drainAsFormData());
+  EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
   EXPECT_FALSE(consumer->drainAsBlobDataHandle());
+  EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
   const char* buffer = nullptr;
   size_t available = 0;
   EXPECT_EQ(Result::Done, consumer->beginRead(&buffer, &available));
   EXPECT_EQ(BytesConsumer::PublicState::Closed, consumer->getPublicState());
 }
 
 TEST_F(FormDataBytesConsumerTest, BeginReadAffectsDraining) {
   const char* buffer = nullptr;
   size_t available = 0;
   BytesConsumer* consumer = new FormDataBytesConsumer("hello, world");
   ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
   EXPECT_EQ("hello, world", String(buffer, available));
 
   ASSERT_EQ(Result::Ok, consumer->endRead(0));
   EXPECT_FALSE(consumer->drainAsFormData());
   EXPECT_FALSE(consumer->drainAsBlobDataHandle());
   EXPECT_EQ(BytesConsumer::PublicState::ReadableOrWaiting,
             consumer->getPublicState());
 }
 
 TEST_F(FormDataBytesConsumerTest, BeginReadAffectsDrainingWithComplexFormData) {
-  MockBytesConsumer* underlying = MockBytesConsumer::create();
   BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
-      getDocument(), complexFormData(), underlying);
+      getDocument(), complexFormData(), WTF::bind(createStubBytesConsumer));
 
   const char* buffer = nullptr;
   size_t available = 0;
+
+  ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
+  ASSERT_EQ(Result::Ok, consumer->endRead(0));
+  EXPECT_FALSE(consumer->drainAsFormData());
+  EXPECT_FALSE(consumer->drainAsBlobDataHandle());
+  EXPECT_EQ(BytesConsumer::PublicState::ReadableOrWaiting,
+            consumer->getPublicState());
+}
+
+// The consumer is cancelled before creating a ByteConsumer for a blob.
+TEST_F(FormDataBytesConsumerTest, CancelWithComplexFormData1) {
+  RefPtr<EncodedFormData> inputFormData = complexFormData();
+
+  MockBytesConsumer* underlying = MockBytesConsumer::create();
+  BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
+      getDocument(), inputFormData,
+      WTF::bind(returnMockBytesConsumer, wrapPersistent(underlying)));
   Checkpoint checkpoint;
 
   InSequence s;
   EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(*underlying, beginRead(&buffer, &available))
-      .WillOnce(Return(Result::Ok));
-  EXPECT_CALL(*underlying, endRead(0)).WillOnce(Return(Result::Ok));
-  EXPECT_CALL(checkpoint, Call(2));
-  // drainAsFormData should not be called here.
-  EXPECT_CALL(checkpoint, Call(3));
-  EXPECT_CALL(*underlying, drainAsBlobDataHandle(_));
-  EXPECT_CALL(checkpoint, Call(4));
-  // |consumer| delegates the getPublicState call to |underlying|.
-  EXPECT_CALL(*underlying, getPublicState())
-      .WillOnce(Return(BytesConsumer::PublicState::ReadableOrWaiting));
-  EXPECT_CALL(checkpoint, Call(5));
-
-  checkpoint.Call(1);
-  ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
-  ASSERT_EQ(Result::Ok, consumer->endRead(0));
-  checkpoint.Call(2);
-  EXPECT_FALSE(consumer->drainAsFormData());
-  checkpoint.Call(3);
-  EXPECT_FALSE(consumer->drainAsBlobDataHandle());
-  checkpoint.Call(4);
-  EXPECT_EQ(BytesConsumer::PublicState::ReadableOrWaiting,
-            consumer->getPublicState());
-  checkpoint.Call(5);
-}
-
-TEST_F(FormDataBytesConsumerTest, SetClientWithComplexFormData) {
-  RefPtr<EncodedFormData> inputFormData = complexFormData();
-
-  MockBytesConsumer* underlying = MockBytesConsumer::create();
-  BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
-      getDocument(), inputFormData, underlying);
-  Checkpoint checkpoint;
-
-  InSequence s;
-  EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(*underlying, setClient(_));
-  EXPECT_CALL(checkpoint, Call(2));
-  EXPECT_CALL(*underlying, clearClient());
-  EXPECT_CALL(checkpoint, Call(3));
-
-  checkpoint.Call(1);
-  consumer->setClient(new NoopClient());
-  checkpoint.Call(2);
-  consumer->clearClient();
-  checkpoint.Call(3);
-}
-
-TEST_F(FormDataBytesConsumerTest, CancelWithComplexFormData) {
-  RefPtr<EncodedFormData> inputFormData = complexFormData();
-
-  MockBytesConsumer* underlying = MockBytesConsumer::create();
-  BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
-      getDocument(), inputFormData, underlying);
-  Checkpoint checkpoint;
-
-  InSequence s;
-  EXPECT_CALL(checkpoint, Call(1));
-  EXPECT_CALL(*underlying, cancel());
   EXPECT_CALL(checkpoint, Call(2));
 
   checkpoint.Call(1);
   consumer->cancel();
   checkpoint.Call(2);
 }
 
+// The consumer is cancelled after creating a ByteConsumer for a blob.
+TEST_F(FormDataBytesConsumerTest, CancelWithComplexFormData2) {
+  RefPtr<EncodedFormData> inputFormData = complexFormData();
+
+  MockBytesConsumer* underlying = MockBytesConsumer::create();
+  BytesConsumer* consumer = FormDataBytesConsumer::createForTesting(
+      getDocument(), inputFormData,
+      WTF::bind(returnMockBytesConsumer, wrapPersistent(underlying)));
+  Checkpoint checkpoint;
+
+  const char* buffer = nullptr;
+  size_t available = 0;
+
+  InSequence s;
+  EXPECT_CALL(checkpoint, Call(1));
+  EXPECT_CALL(checkpoint, Call(2));
+  EXPECT_CALL(*underlying, beginRead(&buffer, &available))
+      .WillOnce(Return(Result::ShouldWait));
+  EXPECT_CALL(checkpoint, Call(3));
+  EXPECT_CALL(*underlying, cancel());
+  EXPECT_CALL(checkpoint, Call(4));
+
+  checkpoint.Call(1);
+  ASSERT_EQ(Result::Ok, consumer->beginRead(&buffer, &available));
+  ASSERT_EQ(3u, available);
+  ASSERT_EQ(Result::Ok, consumer->endRead(available));
+
+  checkpoint.Call(2);
+  ASSERT_EQ(Result::ShouldWait, consumer->beginRead(&buffer, &available));
+
+  checkpoint.Call(3);
+  consumer->cancel();
+  checkpoint.Call(4);
+}
+
 }  // namespace
 }  // namespace blink