Make sxg code use two argument ResponseHeader manipulation calls

We want to get rid of the single argument AddHeader() method as the two
argument AddHeader() and SetHeader() methods are safer and more flexible.

Bug: 1068194
Change-Id: I984a360ff6dfe0e27dc6d583d87ff5b848ff031c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2146935
Auto-Submit: Matt Menke <mmenke@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#759097}

content/browser/loader/prefetch_browsertest.cc

@@ -841,8 +841,8 @@ IN_PROC_BROWSER_TEST_P(PrefetchBrowserTest, SignedExchangeWithPreload) {
   MockSignedExchangeHandlerFactory factory({MockSignedExchangeHandlerParams(
       target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
       GURL(embedded_test_server()->GetURL(target_path)), "text/html",
-      {base::StringPrintf("Link: <%s>;rel=\"preload\";as=\"script\"",
-                          preload_url_in_sxg.spec().c_str())},
+      {{"Link", base::StringPrintf("<%s>;rel=\"preload\";as=\"script\"",
+                                   preload_url_in_sxg.spec().c_str())}},
       net::SHA256HashValue({{0x00}}))});
   ScopedSignedExchangeHandlerFactory scoped_factory(&factory);
 
@@ -917,8 +917,8 @@ IN_PROC_BROWSER_TEST_P(PrefetchBrowserTest,
       target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
       GURL(cross_origin_server_->GetURL("3p.example", target_path)),
       "text/html",
-      {base::StringPrintf("Link: <%s>;rel=\"preload\";as=\"script\"",
-                          preload_url_in_sxg.spec().c_str())},
+      {{"Link", base::StringPrintf("<%s>;rel=\"preload\";as=\"script\"",
+                                   preload_url_in_sxg.spec().c_str())}},
       net::SHA256HashValue({{0x00}}))});
   ScopedSignedExchangeHandlerFactory scoped_factory(&factory);
 

content/browser/web_package/mock_signed_exchange_handler.cc

@@ -20,7 +20,7 @@ MockSignedExchangeHandlerParams::MockSignedExchangeHandlerParams(
     net::Error error,
     const GURL& inner_url,
     const std::string& mime_type,
-    std::vector<std::string> response_headers,
+    std::vector<std::pair<std::string, std::string>> response_headers,
     base::Optional<net::SHA256HashValue> header_integrity,
     const base::Time& signature_expire_time)
     : outer_url(outer_url),
@@ -50,10 +50,9 @@ MockSignedExchangeHandler::MockSignedExchangeHandler(
     head->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK");
     head->mime_type = params.mime_type;
-    head->headers->AddHeader(
-        base::StringPrintf("Content-type: %s", params.mime_type.c_str()));
+    head->headers->SetHeader("Content-type", params.mime_type);
     for (const auto& header : params.response_headers)
-      head->headers->AddHeader(header);
+      head->headers->AddHeader(header.first, header.second);
     head->is_signed_exchange_inner_response = true;
     head->content_length = head->headers->GetContentLength();
   }

content/browser/web_package/mock_signed_exchange_handler.h

@@ -27,7 +27,7 @@ class MockSignedExchangeHandlerParams {
       net::Error error,
       const GURL& inner_url,
       const std::string& mime_type,
-      std::vector<std::string> response_headers,
+      std::vector<std::pair<std::string, std::string>> response_headers,
       base::Optional<net::SHA256HashValue> header_integrity,
       const base::Time& signature_expire_time = base::Time());
   MockSignedExchangeHandlerParams(const MockSignedExchangeHandlerParams& other);
@@ -37,7 +37,7 @@ class MockSignedExchangeHandlerParams {
   const net::Error error;
   const GURL inner_url;
   const std::string mime_type;
-  const std::vector<std::string> response_headers;
+  const std::vector<std::pair<std::string, std::string>> response_headers;
   const base::Optional<net::SHA256HashValue> header_integrity;
   const base::Time signature_expire_time;
 };

content/browser/web_package/signed_exchange_cert_fetcher_unittest.cc

@@ -231,8 +231,8 @@ class SignedExchangeCertFetcherTest : public testing::Test {
     auto response_head = network::mojom::URLResponseHead::New();
     response_head->headers =
         base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK");
-    response_head->headers->AddHeader(
-        "Content-Type: application/cert-chain+cbor");
+    response_head->headers->SetHeader("Content-Type",
+                                      "application/cert-chain+cbor");
     response_head->mime_type = "application/cert-chain+cbor";
     mock_loader_factory_.client_remote()->OnReceiveResponse(
         std::move(response_head));
@@ -482,7 +482,7 @@ TEST_F(SignedExchangeCertFetcherTest, WrongMimeType) {
   auto response_head = network::mojom::URLResponseHead::New();
   response_head->headers =
       base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.1 200 OK");
-  response_head->headers->AddHeader("Content-Type: application/octet-stream");
+  response_head->headers->SetHeader("Content-Type", "application/octet-stream");
   response_head->mime_type = "application/octet-stream";
   mock_loader_factory_.client_remote()->OnReceiveResponse(
       std::move(response_head));

content/browser/web_package/signed_exchange_subresource_prefetch_browsertest.cc

@@ -365,7 +365,8 @@ class SignedExchangePrefetchBrowserTest
       const net::SHA256HashValue& header_integrity,
       const std::string& content,
       const std::vector<std::pair<std::string, std::string>>& sxg_outer_headers,
-      const std::vector<std::string>& sxg_inner_headers = {},
+      const std::vector<std::pair<std::string, std::string>>&
+          sxg_inner_headers = {},
       const base::Time& signature_expire_time = base::Time()) {
     auto sxg_request_counter =
         RequestCounter::CreateAndMonitor(embedded_test_server(), sxg_path);
@@ -490,8 +491,9 @@ IN_PROC_BROWSER_TEST_P(
       "/target.html" /* inner_url_path */,
       net::SHA256HashValue({{0x01}}) /* header_integrity */, content,
       {} /* sxg_outer_headers */,
-      {base::StringPrintf("content-length: %" PRIuS,
-                          content.size())} /* sxg_inner_headers */);
+      {{"content-length",
+        base::StringPrintf("%" PRIuS,
+                           content.size())}} /* sxg_inner_headers */);
   const auto cached_exchanges = GetCachedExchanges(shell());
   // The content of prefetched SXG is larger than the Blob storage limit.
   // So the SXG should not be stored to the cache.
@@ -789,7 +791,6 @@ IN_PROC_BROWSER_TEST_P(SignedExchangePrefetchBrowserTest,
   const std::string outer_link_header =
       CreateAlternateLinkHeader(sxg_script_url, inner_url_script_url);
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString(
           {CreateAllowedAltSxgLinkHeader(inner_url_script_url,
                                          script_header_integrity),
@@ -815,7 +816,7 @@ IN_PROC_BROWSER_TEST_P(SignedExchangePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory(
       {MockSignedExchangeHandlerParams(
            sxg_page_url, SignedExchangeLoadResult::kSuccess, net::OK,
-           inner_url_page_url, "text/html", {inner_link_headers},
+           inner_url_page_url, "text/html", {{"Link", inner_link_headers}},
            page_header_integrity),
        MockSignedExchangeHandlerParams(
            sxg_script_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1076,7 +1077,6 @@ class SignedExchangeSubresourcePrefetchBrowserTest
     const std::string outer_link_header =
         CreateAlternateLinkHeader(sxg_script_url, inner_url_script_url);
     const std::string inner_link_headers =
-        std::string("Link: ") +
         base::JoinString(
             {CreateAllowedAltSxgLinkHeader(inner_url_script_url,
                                            script_header_integrity),
@@ -1106,7 +1106,7 @@ class SignedExchangeSubresourcePrefetchBrowserTest
     MockSignedExchangeHandlerFactory factory(
         {MockSignedExchangeHandlerParams(
              sxg_page_url, SignedExchangeLoadResult::kSuccess, net::OK,
-             inner_url_page_url, "text/html", {inner_link_headers},
+             inner_url_page_url, "text/html", {{"Link", inner_link_headers}},
              page_header_integrity),
          MockSignedExchangeHandlerParams(
              sxg_script_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1213,7 +1213,6 @@ class SignedExchangeSubresourcePrefetchBrowserTest
     const std::string outer_link_header =
         CreateAlternateLinkHeader(script_sxg_url, script_url);
     const std::string inner_link_headers =
-        std::string("Link: ") +
         base::JoinString(
             {CreateAllowedAltSxgLinkHeader(script_url, script_header_integrity),
              CreatePreloadLinkHeader(script_url, "script")},
@@ -1234,15 +1233,16 @@ class SignedExchangeSubresourcePrefetchBrowserTest
                          {{"link", outer_link_header}}));
     RegisterResponse(script_sxg_path,
                      CreateSignedExchangeResponseEntry(content));
-    std::vector<std::string> script_inner_response_headers;
+    std::vector<std::pair<std::string, std::string>>
+        script_inner_response_headers;
     if (has_nosniff) {
-      script_inner_response_headers.emplace_back(
-          "x-content-type-options: nosniff");
+      script_inner_response_headers.emplace_back(std::make_pair(
+          std::string("x-content-type-options"), std::string("nosniff")));
     }
     MockSignedExchangeHandlerFactory factory(
         {MockSignedExchangeHandlerParams(
              target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
-             target_url, "text/html", {inner_link_headers},
+             target_url, "text/html", {{"Link", inner_link_headers}},
              target_header_integrity),
          MockSignedExchangeHandlerParams(
              script_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1517,7 +1517,6 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
                         CreateAlternateLinkHeader(image2_sxg_url, image2_url)},
                        ",");
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString(
           {CreateAllowedAltSxgLinkHeader(image1_url, image1_header_integrity),
            CreateAllowedAltSxgLinkHeader(image2_url, image2_header_integrity),
@@ -1552,7 +1551,7 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory(
       {MockSignedExchangeHandlerParams(
            target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
-           target_url, "text/html", {inner_link_headers},
+           target_url, "text/html", {{"Link", inner_link_headers}},
            target_header_integrity),
        MockSignedExchangeHandlerParams(
            image1_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1633,7 +1632,6 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
        CreateAlternateLinkHeader(script2_sxg_url, script2_url)},
       ",");
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString(
           {CreateAllowedAltSxgLinkHeader(script1_url, script1_header_integrity),
            CreateAllowedAltSxgLinkHeader(script2_url, script2_header_integrity),
@@ -1662,7 +1660,7 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory({
       MockSignedExchangeHandlerParams(
           target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
-          target_url, "text/html", {inner_link_headers},
+          target_url, "text/html", {{"Link", inner_link_headers}},
           target_header_integrity),
       MockSignedExchangeHandlerParams(
           script1_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1748,7 +1746,6 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   // Use the wrong header integrity value for "allowed-alt-sxg" link header to
   // trigger the integrity mismatch fallback logic.
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString({CreateAllowedAltSxgLinkHeader(
                             script_url, wrong_script_header_integrity),
                         CreatePreloadLinkHeader(script_url, "script")},
@@ -1770,7 +1767,7 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory(
       {MockSignedExchangeHandlerParams(
            target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
-           target_url, "text/html", {inner_link_headers},
+           target_url, "text/html", {{"Link", inner_link_headers}},
            target_header_integrity),
        MockSignedExchangeHandlerParams(
            script_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -1836,7 +1833,6 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   // Use the wrong header integrity value for "allowed-alt-sxg" link header for
   // script2 to trigger the integrity mismatch fallback logic.
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString(
           {CreateAllowedAltSxgLinkHeader(script1_url, script1_header_integrity),
            CreateAllowedAltSxgLinkHeader(script2_url,
@@ -1867,7 +1863,7 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory({
       MockSignedExchangeHandlerParams(
           target_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
-          target_url, "text/html", {inner_link_headers},
+          target_url, "text/html", {{"Link", inner_link_headers}},
           target_header_integrity),
       MockSignedExchangeHandlerParams(
           script1_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK,
@@ -2011,7 +2007,7 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest, CORS) {
   const net::SHA256HashValue target_header_integrity = {{0x01}};
 
   std::string target_sxg_outer_link_header;
-  std::string target_sxg_inner_link_header("Link: ");
+  std::string target_sxg_inner_link_header;
   std::string requests_list_string;
 
   std::vector<MockSignedExchangeHandlerParams> mock_params;
@@ -2047,27 +2043,27 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest, CORS) {
             "server", "text/plain",
             {{"Access-Control-Allow-Origin", test_server_origin.c_str()},
              {"Access-Control-Allow-Credentials", "true"}}));
-    std::vector<std::string> data_sxg_inner_headers;
+    std::vector<std::pair<std::string, std::string>> data_sxg_inner_headers;
     if (kTestCases[i].access_control_allow_origin_header) {
-      data_sxg_inner_headers.emplace_back(
-          base::StringPrintf("Access-Control-Allow-Origin: %s",
-                             kTestCases[i].access_control_allow_origin_header));
+      data_sxg_inner_headers.emplace_back(std::make_pair(
+          std::string("Access-Control-Allow-Origin"),
+          std::string(kTestCases[i].access_control_allow_origin_header)));
     }
     if (kTestCases[i].has_access_control_allow_credentials_true_header) {
       data_sxg_inner_headers.emplace_back(
-          "Access-Control-Allow-Credentials: true");
+          std::make_pair(std::string("Access-Control-Allow-Credentials"),
+                         std::string("true")));
     }
     mock_params.emplace_back(
         data_sxg_url, SignedExchangeLoadResult::kSuccess, net::OK, data_url,
         "text/plain", std::move(data_sxg_inner_headers), data_header_integrity);
   }
 
-  std::vector<std::string> target_sxg_inner_headers = {
-      std::move(target_sxg_inner_link_header)};
+  std::vector<std::pair<std::string, std::string>> target_sxg_inner_headers = {
+      {"Link", target_sxg_inner_link_header}};
   mock_params.emplace_back(target_sxg_url, SignedExchangeLoadResult::kSuccess,
                            net::OK, target_url, "text/html",
-                           std::move(target_sxg_inner_headers),
-                           target_header_integrity);
+                           target_sxg_inner_headers, target_header_integrity);
   MockSignedExchangeHandlerFactory factory(std::move(mock_params));
 
   RegisterResponse(
@@ -2179,7 +2175,6 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   const std::string outer_link_header =
       CreateAlternateLinkHeader(sxg_script_url, inner_url_script_url);
   const std::string inner_link_headers =
-      std::string("Link: ") +
       base::JoinString(
           {CreateAllowedAltSxgLinkHeader(inner_url_script_url,
                                          script_header_integrity),
@@ -2201,14 +2196,15 @@ IN_PROC_BROWSER_TEST_F(SignedExchangeSubresourcePrefetchBrowserTest,
   MockSignedExchangeHandlerFactory factory(
       {MockSignedExchangeHandlerParams(
            sxg_page_url, SignedExchangeLoadResult::kSuccess, net::OK,
-           inner_url_page_url, "text/html", {inner_link_headers},
+           inner_url_page_url, "text/html", {{"Link", inner_link_headers}},
            page_header_integrity),
        MockSignedExchangeHandlerParams(
            sxg_script_url, SignedExchangeLoadResult::kSuccess, net::OK,
            inner_url_script_url, "text/javascript",
            // Set "cache-control: public" to keep the script in the memory
            // cache.
-           {"cache-control: public, max-age=600"}, script_header_integrity)});
+           {{"cache-control", "public, max-age=600"}},
+           script_header_integrity)});
   ScopedSignedExchangeHandlerFactory scoped_factory(&factory);
 
   EXPECT_EQ(0, GetPrefetchURLLoaderCallCount());