Convert extensions to use the URLResponseHead mojom types.

Bug: 984550
Change-Id: I885fc575b49c4049b83b17cc4c2248daf2525b4e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1876974Reviewed-by: Karan Bhatia <karandeepb@chromium.org>
Commit-Queue: Lucas Gadani <lfg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709596}

extensions/browser/api/web_request/web_request_info.cc

@@ -23,8 +23,8 @@
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
-#include "services/network/public/cpp/resource_response.h"
 #include "services/network/public/mojom/network_context.mojom.h"
+#include "services/network/public/mojom/url_response_head.mojom.h"
 #include "services/network/url_loader.h"
 
 namespace keys = extension_web_request_api_constants;
@@ -244,7 +244,7 @@ WebRequestInfo::WebRequestInfo(WebRequestInfoInitParams params)
 WebRequestInfo::~WebRequestInfo() = default;
 
 void WebRequestInfo::AddResponseInfoFromResourceResponse(
-    const network::ResourceResponseHead& response) {
+    const network::mojom::URLResponseHead& response) {
   response_headers = response.headers;
   if (response_headers)
     response_code = response_headers->response_code();

extensions/browser/api/web_request/web_request_info.h

@@ -22,13 +22,10 @@
 #include "ipc/ipc_message.h"
 #include "net/http/http_request_headers.h"
 #include "services/network/public/cpp/resource_request.h"
+#include "services/network/public/mojom/url_response_head.mojom-forward.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
-namespace network {
-struct ResourceResponseHead;
-}
-
 namespace extensions {
 
 class ExtensionNavigationUIData;
@@ -91,7 +88,7 @@ struct WebRequestInfo {
 
   // Fill in response data for this request.
   void AddResponseInfoFromResourceResponse(
-      const network::ResourceResponseHead& response);
+      const network::mojom::URLResponseHead& response);
 
   // A unique identifier for this request.
   const uint64_t id;

extensions/browser/api/web_request/web_request_proxying_url_loader_factory.cc

@@ -83,6 +83,7 @@ WebRequestProxyingURLLoaderFactory::InProgressRequest::InProgressRequest(
       proxied_loader_binding_(this, std::move(loader_request)),
       target_client_(std::move(client)),
       proxied_client_binding_(this),
+      current_response_(network::mojom::URLResponseHead::New()),
       has_any_extra_headers_listeners_(
           network_service_request_id_ != 0 &&
           ExtensionWebRequestEventRouter::GetInstance()
@@ -278,12 +279,12 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::OnReceiveResponse(
   if (current_request_uses_header_client_) {
     // Use the headers we got from OnHeadersReceived as that'll contain
     // Set-Cookie if it existed.
-    auto saved_headers = current_response_.headers;
-    current_response_ = head;
-    current_response_.headers = saved_headers;
+    auto saved_headers = current_response_->headers;
+    current_response_ = std::move(head);
+    current_response_->headers = saved_headers;
     ContinueToResponseStarted(net::OK);
   } else {
-    current_response_ = head;
+    current_response_ = std::move(head);
     HandleResponseOrRedirectHeaders(
         base::BindOnce(&InProgressRequest::ContinueToResponseStarted,
                        weak_factory_.GetWeakPtr()));
@@ -304,16 +305,16 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::OnReceiveRedirect(
   if (current_request_uses_header_client_) {
     // Use the headers we got from OnHeadersReceived as that'll contain
     // Set-Cookie if it existed.
-    auto saved_headers = current_response_.headers;
-    current_response_ = head;
+    auto saved_headers = current_response_->headers;
+    current_response_ = std::move(head);
     // If this redirect is from an HSTS upgrade, OnHeadersReceived will not be
     // called before OnReceiveRedirect, so make sure the saved headers exist
     // before setting them.
     if (saved_headers)
-      current_response_.headers = saved_headers;
+      current_response_->headers = saved_headers;
     ContinueToBeforeRedirect(redirect_info, net::OK);
   } else {
-    current_response_ = head;
+    current_response_ = std::move(head);
     HandleResponseOrRedirectHeaders(
         base::BindOnce(&InProgressRequest::ContinueToBeforeRedirect,
                        weak_factory_.GetWeakPtr(), redirect_info));
@@ -369,9 +370,8 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::HandleAuthRequest(
   // Set-Cookie). So we don't use |response_headers| since it won't have the
   // Set-Cookie headers.
   if (!current_request_uses_header_client_) {
-    network::ResourceResponseHead head;
-    head.headers = response_headers;
-    current_response_ = head;
+    current_response_ = network::mojom::URLResponseHead::New();
+    current_response_->headers = response_headers;
   }
   // We first need to simulate |onHeadersReceived| for the response headers
   // which indicated a need to authenticate.
@@ -433,9 +433,10 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::OnHeadersReceived(
   }
 
   on_headers_received_callback_ = std::move(callback);
-  current_response_.headers =
+  current_response_ = network::mojom::URLResponseHead::New();
+  current_response_->headers =
       base::MakeRefCounted<net::HttpResponseHeaders>(headers);
-  current_response_.remote_endpoint = remote_endpoint;
+  current_response_->remote_endpoint = remote_endpoint;
   HandleResponseOrRedirectHeaders(
       base::BindOnce(&InProgressRequest::ContinueToHandleOverrideHeaders,
                      weak_factory_.GetWeakPtr()));
@@ -464,7 +465,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
   redirect_info.new_url = redirect_url_;
   redirect_info.new_site_for_cookies = redirect_url_;
 
-  network::ResourceResponseHead head;
+  auto head = network::mojom::URLResponseHead::New();
   std::string headers = base::StringPrintf(
       "HTTP/1.1 %i Internal Redirect\n"
       "Location: %s\n"
@@ -502,11 +503,11 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
           http_origin.c_str());
     }
   }
-  head.headers = base::MakeRefCounted<net::HttpResponseHeaders>(
+  head->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
       net::HttpUtil::AssembleRawHeaders(headers));
-  head.encoded_data_length = 0;
+  head->encoded_data_length = 0;
 
-  current_response_ = head;
+  current_response_ = std::move(head);
   ContinueToBeforeRedirect(redirect_info, net::OK);
 }
 
@@ -676,7 +677,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::ContinueAuthRequest(
     return;
   }
 
-  info_->AddResponseInfoFromResourceResponse(current_response_);
+  info_->AddResponseInfoFromResourceResponse(*current_response_);
   auto continuation =
       base::BindRepeating(&InProgressRequest::OnAuthRequestHandled,
                           weak_factory_.GetWeakPtr(), base::Passed(&callback));
@@ -754,7 +755,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
       // Make sure to update current_response_,  since when OnReceiveResponse
       // is called we will not use its headers as it might be missing the
       // Set-Cookie line (as that gets stripped over IPC).
-      current_response_.headers = override_headers_;
+      current_response_->headers = override_headers_;
     }
   }
 
@@ -769,7 +770,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
   if (for_cors_preflight_) {
     // If this is for CORS preflight, there is no associated client. We notify
     // the completion here, and deletes |this|.
-    info_->AddResponseInfoFromResourceResponse(current_response_);
+    info_->AddResponseInfoFromResourceResponse(*current_response_);
     ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
         factory_->browser_context_, &info_.value(), net::OK);
     ExtensionWebRequestEventRouter::GetInstance()->OnCompleted(
@@ -794,7 +795,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
 
   DCHECK(!current_request_uses_header_client_ || !override_headers_);
   if (override_headers_)
-    current_response_.headers = override_headers_;
+    current_response_->headers = override_headers_;
 
   std::string redirect_location;
   if (override_headers_ && override_headers_->IsRedirect(&redirect_location)) {
@@ -824,13 +825,13 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
     return;
   }
 
-  info_->AddResponseInfoFromResourceResponse(current_response_);
+  info_->AddResponseInfoFromResourceResponse(*current_response_);
 
   proxied_client_binding_.ResumeIncomingMethodCallProcessing();
 
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
       factory_->browser_context_, &info_.value(), net::OK);
-  target_client_->OnReceiveResponse(current_response_);
+  target_client_->OnReceiveResponse(std::move(current_response_));
 }
 
 void WebRequestProxyingURLLoaderFactory::InProgressRequest::
@@ -841,14 +842,15 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
     return;
   }
 
-  info_->AddResponseInfoFromResourceResponse(current_response_);
+  info_->AddResponseInfoFromResourceResponse(*current_response_);
 
   if (proxied_client_binding_.is_bound())
     proxied_client_binding_.ResumeIncomingMethodCallProcessing();
 
   ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
       factory_->browser_context_, &info_.value(), redirect_info.new_url);
-  target_client_->OnReceiveRedirect(redirect_info, current_response_);
+  target_client_->OnReceiveRedirect(redirect_info,
+                                    std::move(current_response_));
   request_.url = redirect_info.new_url;
   request_.method = redirect_info.new_method;
   request_.site_for_cookies = redirect_info.new_site_for_cookies;
@@ -875,7 +877,7 @@ void WebRequestProxyingURLLoaderFactory::InProgressRequest::
     int result =
         ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
             factory_->browser_context_, &info_.value(), copyable_callback,
-            current_response_.headers.get(), &override_headers_,
+            current_response_->headers.get(), &override_headers_,
             &redirect_url_);
     if (result == net::ERR_BLOCKED_BY_CLIENT) {
       OnRequestError(network::URLLoaderCompletionStatus(result));

extensions/browser/api/web_request/web_request_proxying_url_loader_factory.h

@@ -27,10 +27,10 @@
 #include "net/base/completion_once_callback.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "services/network/public/cpp/resource_request.h"
-#include "services/network/public/cpp/resource_response.h"
 #include "services/network/public/mojom/network_context.mojom.h"
 #include "services/network/public/mojom/url_loader.mojom.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
+#include "services/network/public/mojom/url_response_head.mojom.h"
 #include "url/gurl.h"
 
 namespace extensions {
@@ -153,7 +153,7 @@ class WebRequestProxyingURLLoaderFactory
     // |OnHeadersReceived()| and request completion or restart. Pointers to
     // these fields are stored in a |BlockedRequest| (created and owned by
     // ExtensionWebRequestEventRouter) through much of the request's lifetime.
-    network::ResourceResponseHead current_response_;
+    network::mojom::URLResponseHeadPtr current_response_;
     scoped_refptr<net::HttpResponseHeaders> override_headers_;
     GURL redirect_url_;
 

extensions/browser/api/web_request/web_request_proxying_websocket.cc

@@ -58,6 +58,7 @@ WebRequestProxyingWebSocket::WebRequestProxyingWebSocket(
       browser_context_(browser_context),
       forwarding_handshake_client_(std::move(handshake_client)),
       request_headers_(request.headers),
+      response_(network::mojom::URLResponseHead::New()),
       has_extra_headers_(has_extra_headers),
       info_(WebRequestInfoInitParams(request_id_generator->Generate(),
                                      process_id,
@@ -143,7 +144,7 @@ void WebRequestProxyingWebSocket::ContinueToHeadersReceived() {
       &WebRequestProxyingWebSocket::OnHeadersReceivedComplete,
       weak_factory_.GetWeakPtr());
   int result = ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
-      browser_context_, &info_, continuation, response_.headers.get(),
+      browser_context_, &info_, continuation, response_->headers.get(),
       &override_headers_, &redirect_url_);
 
   if (result == net::ERR_BLOCKED_BY_CLIENT) {
@@ -176,23 +177,23 @@ void WebRequestProxyingWebSocket::OnConnectionEstablished(
   handshake_response_ = std::move(response);
   readable_ = std::move(readable);
 
-  response_.remote_endpoint = handshake_response_->remote_endpoint;
+  response_->remote_endpoint = handshake_response_->remote_endpoint;
 
-  // response_.headers will be set in OnBeforeSendHeaders if
+  // response_->headers will be set in OnBeforeSendHeaders if
   // |receiver_as_header_client_| is set.
   if (receiver_as_header_client_.is_bound()) {
     ContinueToCompleted();
     return;
   }
 
-  response_.headers =
+  response_->headers =
       base::MakeRefCounted<net::HttpResponseHeaders>(base::StringPrintf(
           "HTTP/%d.%d %d %s", handshake_response_->http_version.major_value(),
           handshake_response_->http_version.minor_value(),
           handshake_response_->status_code,
           handshake_response_->status_text.c_str()));
   for (const auto& header : handshake_response_->headers)
-    response_.headers->AddHeader(header->name + ": " + header->value);
+    response_->headers->AddHeader(header->name + ": " + header->value);
 
   ContinueToHeadersReceived();
 }
@@ -220,15 +221,15 @@ void WebRequestProxyingWebSocket::OnAuthRequired(
     return;
   }
 
-  response_.headers = headers;
-  response_.remote_endpoint = remote_endpoint;
+  response_->headers = headers;
+  response_->remote_endpoint = remote_endpoint;
   auth_required_callback_ = std::move(callback);
 
   auto continuation = base::BindRepeating(
       &WebRequestProxyingWebSocket::OnHeadersReceivedCompleteForAuth,
       weak_factory_.GetWeakPtr(), auth_info);
   int result = ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
-      browser_context_, &info_, continuation, response_.headers.get(),
+      browser_context_, &info_, continuation, response_->headers.get(),
       &override_headers_, &redirect_url_);
 
   if (result == net::ERR_BLOCKED_BY_CLIENT) {
@@ -261,7 +262,7 @@ void WebRequestProxyingWebSocket::OnHeadersReceived(
   DCHECK(receiver_as_header_client_.is_bound());
 
   on_headers_received_callback_ = std::move(callback);
-  response_.headers = base::MakeRefCounted<net::HttpResponseHeaders>(headers);
+  response_->headers = base::MakeRefCounted<net::HttpResponseHeaders>(headers);
 
   ContinueToHeadersReceived();
 }
@@ -409,12 +410,12 @@ void WebRequestProxyingWebSocket::OnHeadersReceivedComplete(int error_code) {
   }
 
   if (override_headers_) {
-    response_.headers = override_headers_;
+    response_->headers = override_headers_;
     override_headers_ = nullptr;
   }
 
   ResumeIncomingMethodCallProcessing();
-  info_.AddResponseInfoFromResourceResponse(response_);
+  info_.AddResponseInfoFromResourceResponse(*response_);
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
       browser_context_, &info_, net::OK);
 
@@ -453,7 +454,7 @@ void WebRequestProxyingWebSocket::OnHeadersReceivedCompleteForAuth(
     return;
   }
   ResumeIncomingMethodCallProcessing();
-  info_.AddResponseInfoFromResourceResponse(response_);
+  info_.AddResponseInfoFromResourceResponse(*response_);
 
   auto continuation =
       base::BindRepeating(&WebRequestProxyingWebSocket::OnAuthRequiredComplete,

extensions/browser/api/web_request/web_request_proxying_websocket.h

@@ -20,8 +20,8 @@
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "services/network/public/cpp/resource_request.h"
-#include "services/network/public/cpp/resource_response.h"
 #include "services/network/public/mojom/network_context.mojom.h"
+#include "services/network/public/mojom/url_response_head.mojom.h"
 #include "services/network/public/mojom/websocket.mojom.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ -128,7 +128,7 @@ class WebRequestProxyingWebSocket
       receiver_as_header_client_{this};
 
   net::HttpRequestHeaders request_headers_;
-  network::ResourceResponseHead response_;
+  network::mojom::URLResponseHeadPtr response_;
   net::AuthCredentials auth_credentials_;
   OnAuthRequiredCallback auth_required_callback_;
   scoped_refptr<net::HttpResponseHeaders> override_headers_;

extensions/browser/extension_protocols.cc

@@ -77,8 +77,8 @@
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
-#include "services/network/public/cpp/resource_response.h"
 #include "services/network/public/cpp/url_loader_completion_status.h"
+#include "services/network/public/mojom/url_response_head.mojom.h"
 #include "third_party/blink/public/common/features.h"
 #include "url/url_util.h"
 
@@ -460,13 +460,13 @@ class ExtensionURLLoaderFactory : public network::mojom::URLLoaderFactory {
       // chunk of HTML.
 
       // Leave cache headers out of generated background page jobs.
-      network::ResourceResponseHead head;
+      auto head = network::mojom::URLResponseHead::New();
       const bool send_cors_headers = false;
-      head.headers = BuildHttpHeaders(content_security_policy,
-                                      send_cors_headers, base::Time());
+      head->headers = BuildHttpHeaders(content_security_policy,
+                                       send_cors_headers, base::Time());
       std::string contents;
-      GenerateBackgroundPageContents(extension.get(), &head.mime_type,
-                                     &head.charset, &contents);
+      GenerateBackgroundPageContents(extension.get(), &head->mime_type,
+                                     &head->charset, &contents);
       uint32_t size = base::saturated_cast<uint32_t>(contents.size());
       mojo::DataPipe pipe(size);
       MojoResult result = pipe.producer_handle->WriteData(
@@ -476,7 +476,7 @@ class ExtensionURLLoaderFactory : public network::mojom::URLLoaderFactory {
         return;
       }
 
-      client->OnReceiveResponse(head);
+      client->OnReceiveResponse(std::move(head));
       client->OnStartLoadingResponseBody(std::move(pipe.consumer_handle));
       client->OnComplete(network::URLLoaderCompletionStatus(net::OK));
       return;