CDP: report binary post data in Network and Fetch domains

This change introduces a binary post data field in the Network.Request
type. New field contains entries that correspond to the http body data
entries. New PostDataEntry type supports text/bytes data only, but
allows progressive enhancement for other types such as files and blobs.

Bug: 1107728
Change-Id: I205dd7fc93d627a14c111cc2a05a63ce962bc449
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2309660Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Commit-Queue: Pavel Feldman <pfeldman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#790513}

content/browser/devtools/protocol/network_handler.cc

@@ -494,8 +494,10 @@ String GetProtocol(const GURL& url,
   return protocol;
 }
 
-bool GetPostData(const network::ResourceRequestBody& request_body,
-                 std::string* result) {
+bool GetPostData(
+    const network::ResourceRequestBody& request_body,
+    protocol::Array<protocol::Network::PostDataEntry>* data_entries,
+    std::string* result) {
   const std::vector<network::DataElement>* elements = request_body.elements();
   if (elements->empty())
     return false;
@@ -503,7 +505,11 @@ bool GetPostData(const network::ResourceRequestBody& request_body,
     // TODO(caseq): Also support blobs.
     if (element.type() != network::mojom::DataElementType::kBytes)
       return false;
-    // TODO(caseq): This should rather be sent as Binary.
+    auto bytes = protocol::Binary::fromSpan(
+        reinterpret_cast<const uint8_t*>(element.bytes()), element.length());
+    auto data_entry = protocol::Network::PostDataEntry::Create().Build();
+    data_entry->SetBytes(std::move(bytes));
+    data_entries->push_back(std::move(data_entry));
     result->append(element.bytes(), element.length());
   }
   return true;
@@ -1630,10 +1636,17 @@ void NetworkHandler::NavigationRequestWillBeSent(
   if (!url_fragment.empty())
     request->SetUrlFragment(url_fragment);
 
-  std::string post_data;
-  if (common_params.post_data &&
-      GetPostData(*common_params.post_data, &post_data)) {
-    request->SetPostData(post_data);
+  if (common_params.post_data) {
+    std::string post_data;
+    auto data_entries =
+        std::make_unique<protocol::Array<protocol::Network::PostDataEntry>>();
+    if (GetPostData(*common_params.post_data, data_entries.get(), &post_data)) {
+      if (!post_data.empty())
+        request->SetPostData(post_data);
+      if (data_entries->size())
+        request->SetPostDataEntries(std::move(data_entries));
+      request->SetHasPostData(true);
+    }
   }
   // TODO(caseq): report potentially blockable types
   request->SetMixedContentType(Security::MixedContentTypeEnum::None);
@@ -2040,9 +2053,18 @@ NetworkHandler::CreateRequestFromResourceRequest(
           .Build();
   if (!url_fragment.empty())
     request_object->SetUrlFragment(url_fragment);
-  std::string post_data;
-  if (request.request_body && GetPostData(*request.request_body, &post_data))
-    request_object->SetPostData(std::move(post_data));
+  if (request.request_body) {
+    std::string post_data;
+    auto data_entries =
+        std::make_unique<protocol::Array<protocol::Network::PostDataEntry>>();
+    if (GetPostData(*request.request_body, data_entries.get(), &post_data)) {
+      if (!post_data.empty())
+        request_object->SetPostData(std::move(post_data));
+      if (data_entries->size())
+        request_object->SetPostDataEntries(std::move(data_entries));
+      request_object->SetHasPostData(true);
+    }
+  }
   return request_object;
 }
 

third_party/blink/public/devtools_protocol/browser_protocol.pdl

@@ -4260,6 +4260,11 @@ domain Network
       High
       VeryHigh
 
+  # Post data entry for HTTP request
+  type PostDataEntry extends object
+    properties
+      optional binary bytes
+
   # HTTP request data.
   type Request extends object
     properties
@@ -4275,6 +4280,8 @@ domain Network
       optional string postData
       # True when the request has POST data. Note that postData might still be omitted when this flag is true when the data is too long.
       optional boolean hasPostData
+      # Request body elements. This will be converted from base64 to binary
+      experimental optional array of PostDataEntry postDataEntries
       # The mixed content type of the request.
       optional Security.MixedContentType mixedContentType
       # Priority of the resource request at the time request is sent.

third_party/blink/renderer/core/inspector/inspector_network_agent.cc

@@ -523,9 +523,11 @@ static std::unique_ptr<protocol::Network::ResourceTiming> BuildObjectForTiming(
       .build();
 }
 
-static bool FormDataToString(scoped_refptr<EncodedFormData> body,
-                             size_t max_body_size,
-                             String* content) {
+static bool FormDataToString(
+    scoped_refptr<EncodedFormData> body,
+    size_t max_body_size,
+    protocol::Array<protocol::Network::PostDataEntry>* data_entries,
+    String* content) {
   *content = "";
   if (!body || body->IsEmpty())
     return false;
@@ -540,6 +542,15 @@ static bool FormDataToString(scoped_refptr<EncodedFormData> body,
   if (max_body_size != 0 && body->SizeInBytes() > max_body_size)
     return true;
 
+  for (const auto& element : body->Elements()) {
+    auto data_entry = protocol::Network::PostDataEntry::create().build();
+    auto bytes = protocol::Binary::fromSpan(
+        reinterpret_cast<const uint8_t*>(element.data_.data()),
+        element.data_.size());
+    data_entry->setBytes(std::move(bytes));
+    data_entries->push_back(std::move(data_entry));
+  }
+
   Vector<char> bytes;
   body->Flatten(bytes);
   *content = String::FromUTF8WithLatin1Fallback(bytes.data(), bytes.size());
@@ -550,8 +561,11 @@ static std::unique_ptr<protocol::Network::Request>
 BuildObjectForResourceRequest(const ResourceRequest& request,
                               scoped_refptr<EncodedFormData> post_data,
                               size_t max_body_size) {
-  String postData;
-  bool hasPostData = FormDataToString(post_data, max_body_size, &postData);
+  String data_string;
+  auto data_entries =
+      std::make_unique<protocol::Array<protocol::Network::PostDataEntry>>();
+  bool has_post_data = FormDataToString(post_data, max_body_size,
+                                        data_entries.get(), &data_string);
   KURL url = request.Url();
   // protocol::Network::Request doesn't have a separate referrer string member
   // like blink::ResourceRequest, so here we add ResourceRequest's referrer
@@ -572,9 +586,11 @@ BuildObjectForResourceRequest(const ResourceRequest& request,
           .build();
   if (url.FragmentIdentifier())
     result->setUrlFragment("#" + url.FragmentIdentifier());
-  if (!postData.IsEmpty())
-    result->setPostData(postData);
-  if (hasPostData)
+  if (!data_string.IsEmpty())
+    result->setPostData(data_string);
+  if (data_entries->size())
+    result->setPostDataEntries(std::move(data_entries));
+  if (has_post_data)
     result->setHasPostData(true);
   return result;
 }

third_party/blink/web_tests/http/tests/inspector-protocol/fetch/fetch-post-data-expected.txt

+Test post data interception
+[
+    [0] : {
+        bytes : AQIDBAU=
+    }
+]
+[
+    [0] : {
+        bytes : AQIDBAU=
+    }
+]
+

third_party/blink/web_tests/http/tests/inspector-protocol/fetch/fetch-post-data.js

+(async function(testRunner) {
+  const {page, session, dp} = await testRunner.startBlank(
+      `Test post data interception`);
+
+  await dp.Network.enable();
+  await dp.Fetch.enable();
+
+  const [requestWillBeSent, requestPaused] = await Promise.all([
+    dp.Network.onceRequestWillBeSent(),
+    dp.Fetch.onceRequestPaused(),
+    session.evaluate(`fetch('${testRunner.url('./resources/hello-world.txt')}', {
+                          method: 'post',
+                          body: new Uint8Array([1, 2, 3, 4, 5])
+                      })`)
+  ]);
+  testRunner.log(requestWillBeSent.params.request.postDataEntries);
+  testRunner.log(requestPaused.params.request.postDataEntries);
+  testRunner.completeTest();
+})