[fetch] Add network::mojom::DataElementType::kReadOnceStream enum value.

This CL adds kReadOnceStream enum value for fetch upload streaming
instead of kChunkedDataPipe.
kReadOnceStream means the data is non repeatable unlike
kChunkedDataPipe.

This is a preparation for
"[fetch] Cache request stream body up to 64k bytes."
(crrev.com/c/2269622)

Bug: 1077174, 688906
Change-Id: I78c45777eb85751b20287bab6e55be0dd3502cb1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2342525
Commit-Queue: Yoichi Osato <yoichio@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798515}

content/common/page_state_serialization.cc

@@ -710,6 +710,7 @@ void WriteResourceRequestBody(const network::ResourceRequestBody& request_body,
         break;
       case network::mojom::DataElementType::kRawFile:
       case network::mojom::DataElementType::kChunkedDataPipe:
+      case network::mojom::DataElementType::kReadOnceStream:
       case network::mojom::DataElementType::kUnknown:
         NOTREACHED();
         continue;

content/renderer/loader/web_url_request_util.cc

@@ -147,6 +147,7 @@ WebHTTPBody GetWebHTTPBodyForRequestBody(
       case network::mojom::DataElementType::kUnknown:
       case network::mojom::DataElementType::kRawFile:
       case network::mojom::DataElementType::kChunkedDataPipe:
+      case network::mojom::DataElementType::kReadOnceStream:
         NOTREACHED();
         break;
     }

services/network/public/cpp/data_element.cc

@@ -77,6 +77,13 @@ void DataElement::SetToChunkedDataPipe(
   chunked_data_pipe_getter_ = std::move(chunked_data_pipe_getter);
 }
 
+void DataElement::SetToReadOnceStream(
+    mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
+        chunked_data_pipe_getter) {
+  type_ = mojom::DataElementType::kReadOnceStream;
+  chunked_data_pipe_getter_ = std::move(chunked_data_pipe_getter);
+}
+
 base::File DataElement::ReleaseFile() {
   return std::move(file_);
 }
@@ -103,7 +110,9 @@ mojo::PendingRemote<mojom::DataPipeGetter> DataElement::CloneDataPipeGetter()
 
 mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
 DataElement::ReleaseChunkedDataPipeGetter() {
-  DCHECK_EQ(mojom::DataElementType::kChunkedDataPipe, type_);
+  DCHECK(type_ == mojom::DataElementType::kChunkedDataPipe ||
+         type_ == mojom::DataElementType::kReadOnceStream)
+      << type_;
   return std::move(chunked_data_pipe_getter_);
 }
 
@@ -138,6 +147,9 @@ void PrintTo(const DataElement& x, std::ostream* os) {
     case mojom::DataElementType::kChunkedDataPipe:
       *os << "TYPE_CHUNKED_DATA_PIPE";
       break;
+    case mojom::DataElementType::kReadOnceStream:
+      *os << "TYPE_READ_ONCE_STREAM";
+      break;
     case mojom::DataElementType::kUnknown:
       *os << "TYPE_UNKNOWN";
       break;
@@ -164,6 +176,8 @@ bool operator==(const DataElement& a, const DataElement& b) {
       return false;
     case mojom::DataElementType::kChunkedDataPipe:
       return false;
+    case mojom::DataElementType::kReadOnceStream:
+      return false;
     case mojom::DataElementType::kUnknown:
       NOTREACHED();
       return false;

services/network/public/cpp/data_element.h

@@ -169,6 +169,10 @@ class COMPONENT_EXPORT(NETWORK_CPP_BASE) DataElement {
   // server known to support chunked uploads.
   void SetToChunkedDataPipe(mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
                                 chunked_data_pipe_getter);
+  // Almost same as above except |chunked_data_pipe_getter| is read only once
+  // and you must talk with a server supporting chunked upload.
+  void SetToReadOnceStream(mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
+                               chunked_data_pipe_getter);
 
   // Takes ownership of the File, if this is of TYPE_RAW_FILE. The file is open
   // for reading (asynchronous reading on Windows).

services/network/public/cpp/network_ipc_param_traits.cc

@@ -57,6 +57,7 @@ void ParamTraits<network::DataElement>::Write(base::Pickle* m,
                         .release());
       break;
     }
+    case network::mojom::DataElementType::kReadOnceStream:
     case network::mojom::DataElementType::kUnknown: {
       NOTREACHED();
       break;
@@ -148,6 +149,7 @@ bool ParamTraits<network::DataElement>::Read(const base::Pickle* m,
       r->SetToChunkedDataPipe(std::move(chunked_data_pipe_getter));
       return true;
     }
+    case network::mojom::DataElementType::kReadOnceStream:
     case network::mojom::DataElementType::kUnknown: {
       NOTREACHED();
       return false;

services/network/public/cpp/resource_request_body.cc

@@ -21,9 +21,15 @@ scoped_refptr<ResourceRequestBody> ResourceRequestBody::CreateFromBytes(
   return result;
 }
 
+bool ResourceRequestBody::EnableToAppendElement() const {
+  return elements_.empty() ||
+         (elements_.front().type() !=
+              mojom::DataElementType::kChunkedDataPipe &&
+          elements_.front().type() != mojom::DataElementType::kReadOnceStream);
+}
+
 void ResourceRequestBody::AppendBytes(std::vector<uint8_t> bytes) {
-  DCHECK(elements_.empty() ||
-         elements_.front().type() != mojom::DataElementType::kChunkedDataPipe);
+  DCHECK(EnableToAppendElement());
 
   if (bytes.size() > 0) {
     elements_.push_back(DataElement());
@@ -44,8 +50,7 @@ void ResourceRequestBody::AppendFileRange(
     uint64_t offset,
     uint64_t length,
     const base::Time& expected_modification_time) {
-  DCHECK(elements_.empty() ||
-         elements_.front().type() != mojom::DataElementType::kChunkedDataPipe);
+  DCHECK(EnableToAppendElement());
 
   elements_.push_back(DataElement());
   elements_.back().SetToFilePathRange(file_path, offset, length,
@@ -58,8 +63,7 @@ void ResourceRequestBody::AppendRawFileRange(
     uint64_t offset,
     uint64_t length,
     const base::Time& expected_modification_time) {
-  DCHECK(elements_.empty() ||
-         elements_.front().type() != mojom::DataElementType::kChunkedDataPipe);
+  DCHECK(EnableToAppendElement());
 
   elements_.push_back(DataElement());
   elements_.back().SetToFileRange(std::move(file), file_path, offset, length,
@@ -71,8 +75,7 @@ void ResourceRequestBody::AppendBlob(const std::string& uuid) {
 }
 
 void ResourceRequestBody::AppendBlob(const std::string& uuid, uint64_t length) {
-  DCHECK(elements_.empty() ||
-         elements_.front().type() != mojom::DataElementType::kChunkedDataPipe);
+  DCHECK(EnableToAppendElement());
 
   elements_.push_back(DataElement());
   elements_.back().SetToBlobRange(uuid, 0 /* offset */, length);
@@ -80,8 +83,7 @@ void ResourceRequestBody::AppendBlob(const std::string& uuid, uint64_t length) {
 
 void ResourceRequestBody::AppendDataPipe(
     mojo::PendingRemote<mojom::DataPipeGetter> data_pipe_getter) {
-  DCHECK(elements_.empty() ||
-         elements_.front().type() != mojom::DataElementType::kChunkedDataPipe);
+  DCHECK(EnableToAppendElement());
 
   elements_.push_back(DataElement());
   elements_.back().SetToDataPipe(std::move(data_pipe_getter));
@@ -96,6 +98,15 @@ void ResourceRequestBody::SetToChunkedDataPipe(
   elements_.back().SetToChunkedDataPipe(std::move(chunked_data_pipe_getter));
 }
 
+void ResourceRequestBody::SetToReadOnceStream(
+    mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
+        chunked_data_pipe_getter) {
+  DCHECK(elements_.empty());
+
+  elements_.push_back(DataElement());
+  elements_.back().SetToReadOnceStream(std::move(chunked_data_pipe_getter));
+}
+
 std::vector<base::FilePath> ResourceRequestBody::GetReferencedFiles() const {
   std::vector<base::FilePath> result;
   for (const auto& element : *elements()) {

services/network/public/cpp/resource_request_body.h

@@ -80,6 +80,10 @@ class COMPONENT_EXPORT(NETWORK_CPP_BASE) ResourceRequestBody
   // support chunked uploads.
   void SetToChunkedDataPipe(mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
                                 chunked_data_pipe_getter);
+  // Almost same as above except |chunked_data_pipe_getter| is read only once
+  // and you must talk with a server supporting chunked upload.
+  void SetToReadOnceStream(mojo::PendingRemote<mojom::ChunkedDataPipeGetter>
+                               chunked_data_pipe_getter);
   void SetAllowHTTP1ForStreamingUpload(bool allow) {
     allow_http1_for_streaming_upload_ = allow;
   }
@@ -118,6 +122,8 @@ class COMPONENT_EXPORT(NETWORK_CPP_BASE) ResourceRequestBody
                                    scoped_refptr<network::ResourceRequestBody>>;
   ~ResourceRequestBody();
 
+  bool EnableToAppendElement() const;
+
   std::vector<DataElement> elements_;
   int64_t identifier_;
 

services/network/public/cpp/url_request_mojom_traits.h

@@ -327,7 +327,8 @@ struct COMPONENT_EXPORT(NETWORK_CPP_BASE)
   }
   static mojo::PendingRemote<network::mojom::ChunkedDataPipeGetter>
   chunked_data_pipe_getter(const network::DataElement& element) {
-    if (element.type_ != network::mojom::DataElementType::kChunkedDataPipe)
+    if (element.type_ != network::mojom::DataElementType::kChunkedDataPipe &&
+        element.type_ != network::mojom::DataElementType::kReadOnceStream)
       return mojo::NullRemote();
     return const_cast<network::DataElement&>(element)
         .ReleaseChunkedDataPipeGetter();

services/network/public/mojom/url_loader.mojom

@@ -62,6 +62,7 @@ enum DataElementType {
   // Only used for Upload with Network Service as of now:
   kDataPipe,
   kChunkedDataPipe,
+  kReadOnceStream,
   kRawFile,
 
   // Used for Upload when Network Service is disabled:

services/network/url_loader.cc

@@ -210,12 +210,14 @@ std::unique_ptr<net::UploadDataStream> CreateUploadDataStream(
     std::vector<base::File>& opened_files,
     base::SequencedTaskRunner* file_task_runner) {
   // In the case of a chunked upload, there will just be one element.
-  if (body->elements()->size() == 1 &&
-      body->elements()->begin()->type() ==
-          network::mojom::DataElementType::kChunkedDataPipe) {
-    return std::make_unique<ChunkedDataPipeUploadDataStream>(
-        body, const_cast<DataElement&>(body->elements()->front())
-                  .ReleaseChunkedDataPipeGetter());
+  if (body->elements()->size() == 1) {
+    network::mojom::DataElementType type = body->elements()->begin()->type();
+    if (type == network::mojom::DataElementType::kChunkedDataPipe ||
+        type == network::mojom::DataElementType::kReadOnceStream) {
+      return std::make_unique<ChunkedDataPipeUploadDataStream>(
+          body,
+          body->elements_mutable()->begin()->ReleaseChunkedDataPipeGetter());
+    }
   }
 
   auto opened_file = opened_files.begin();
@@ -244,7 +246,8 @@ std::unique_ptr<net::UploadDataStream> CreateUploadDataStream(
             body, element.CloneDataPipeGetter()));
         break;
       }
-      case network::mojom::DataElementType::kChunkedDataPipe: {
+      case network::mojom::DataElementType::kChunkedDataPipe:
+      case network::mojom::DataElementType::kReadOnceStream: {
         // This shouldn't happen, as the traits logic should ensure that if
         // there's a chunked pipe, there's one and only one element.
         NOTREACHED();
@@ -1095,22 +1098,13 @@ void URLLoader::OnReceivedRedirect(net::URLRequest* url_request,
 
 // static
 bool URLLoader::HasFetchStreamingUploadBody(const ResourceRequest* request) {
-  // Follows blink::mojom::ResourceType::kXhr.
-  const int kXhr = 13;
-  if (request->resource_type != kXhr)
-    return false;
   const ResourceRequestBody* request_body = request->request_body.get();
   if (!request_body)
     return false;
   const std::vector<DataElement>* elements = request_body->elements();
-  if (elements->size() == 0u)
-    return false;
-  // https://fetch.spec.whatwg.org/#concept-bodyinit-extract
-  // Body's source is null means the body is not extracted from ReadableStream.
-  // See blink::PopulateResourceRequest() for actual construction.
-  if (elements->size() > 1u)
+  if (elements->size() != 1u)
     return false;
-  return elements->at(0).type() == mojom::DataElementType::kChunkedDataPipe;
+  return elements->front().type() == mojom::DataElementType::kReadOnceStream;
 }
 
 void URLLoader::OnAuthRequired(net::URLRequest* url_request,

third_party/blink/public/common/fetch/fetch_api_request_body_mojom_traits.h

@@ -79,7 +79,7 @@ struct BLINK_COMMON_EXPORT
   }
   static mojo::PendingRemote<network::mojom::ChunkedDataPipeGetter>
   chunked_data_pipe_getter(const network::DataElement& element) {
-    if (element.type_ != network::mojom::DataElementType::kChunkedDataPipe)
+    if (element.type_ != network::mojom::DataElementType::kReadOnceStream)
       return mojo::NullRemote();
     return const_cast<network::DataElement&>(element)
         .ReleaseChunkedDataPipeGetter();

third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.cc

@@ -28,7 +28,7 @@ StructTraits<blink::mojom::FetchAPIRequestBodyDataView,
 
   if (mutable_body.StreamBody()) {
     auto out = blink::mojom::blink::FetchAPIDataElement::New();
-    out->type = network::mojom::DataElementType::kChunkedDataPipe;
+    out->type = network::mojom::DataElementType::kReadOnceStream;
     out->chunked_data_pipe_getter = mutable_body.TakeStreamBody();
     out_elements.push_back(std::move(out));
     return out_elements;
@@ -105,7 +105,7 @@ bool StructTraits<blink::mojom::FetchAPIRequestBodyDataView,
     if (!view.ReadType(&type)) {
       return false;
     }
-    if (type == network::mojom::DataElementType::kChunkedDataPipe) {
+    if (type == network::mojom::DataElementType::kReadOnceStream) {
       auto chunked_data_pipe_getter = view.TakeChunkedDataPipeGetter<
           mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter>>();
       *out = blink::ResourceRequestBody(std::move(chunked_data_pipe_getter));
@@ -162,6 +162,7 @@ bool StructTraits<blink::mojom::FetchAPIRequestBodyDataView,
       case network::mojom::DataElementType::kBlob:
       case network::mojom::DataElementType::kUnknown:
       case network::mojom::DataElementType::kChunkedDataPipe:
+      case network::mojom::DataElementType::kReadOnceStream:
       case network::mojom::DataElementType::kRawFile:
         NOTREACHED();
         return false;

third_party/blink/renderer/platform/loader/fetch/url_loader/request_conversion.cc

@@ -358,7 +358,7 @@ void PopulateResourceRequest(const ResourceRequestHead& src,
     dest->request_body = base::MakeRefCounted<network::ResourceRequestBody>();
     mojo::PendingRemote<network::mojom::ChunkedDataPipeGetter>
         network_stream_body(stream_body.PassPipe(), 0u);
-    dest->request_body->SetToChunkedDataPipe(std::move(network_stream_body));
+    dest->request_body->SetToReadOnceStream(std::move(network_stream_body));
     dest->request_body->SetAllowHTTP1ForStreamingUpload(
         src.AllowHTTP1ForStreamingUpload());
   }