Make sure the default CSP is used for <webview> with PlzNavigate.

chrome/browser/net/chrome_extensions_network_delegate.cc

 // Copyright 2014 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 "chrome/browser/net/chrome_extensions_network_delegate.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "net/base/net_errors.h"
@@ skipping 65 matching lines @@
 
   int process_id, render_frame_id;
   if (info->GetAssociatedRenderFrame(&process_id, &render_frame_id)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NotifyEPMRequestStatus, status, profile_id,
                    request->identifier(), process_id, render_frame_id));
   }
 }
 
-extensions::ExtensionNavigationUIData* GetExtensionNavigationUIData(
-    net::URLRequest* request) {
-  const content::ResourceRequestInfo* info =
-      content::ResourceRequestInfo::ForRequest(request);
-  if (!info)
-    return nullptr;
-  ChromeNavigationUIData* navigation_data =
-      static_cast<ChromeNavigationUIData*>(info->GetNavigationUIData());
-  if (!navigation_data)
-    return nullptr;
-  return navigation_data->GetExtensionNavigationUIData();
-}
-
 class ChromeExtensionsNetworkDelegateImpl
     : public ChromeExtensionsNetworkDelegate {
  public:
   explicit ChromeExtensionsNetworkDelegateImpl(
       extensions::EventRouterForwarder* event_router);
   ~ChromeExtensionsNetworkDelegateImpl() override;
 
  private:
   // ChromeExtensionsNetworkDelegate implementation.
   void ForwardProxyErrors(net::URLRequest* request, int net_error) override;
@@ skipping 62 matching lines @@
 void ChromeExtensionsNetworkDelegateImpl::ForwardDoneRequestStatus(
     net::URLRequest* request) {
   ForwardRequestStatus(REQUEST_DONE, request, profile_);
 }
 
 int ChromeExtensionsNetworkDelegateImpl::OnBeforeURLRequest(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRequest(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, callback, new_url);
+      profile_, extension_info_map_.get(), request, callback, new_url);
 }
 
 int ChromeExtensionsNetworkDelegateImpl::OnBeforeStartTransaction(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeSendHeaders(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, callback, headers);
+      profile_, extension_info_map_.get(), request, callback, headers);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnStartTransaction(
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   ExtensionWebRequestEventRouter::GetInstance()->OnSendHeaders(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, headers);
+      profile_, extension_info_map_.get(), request, headers);
 }
 
 int ChromeExtensionsNetworkDelegateImpl::OnHeadersReceived(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, callback,
+      profile_, extension_info_map_.get(), request, callback,
       original_response_headers, override_response_headers,
       allowed_unsafe_redirect_url);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnBeforeRedirect(
     net::URLRequest* request,
     const GURL& new_location) {
   ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, new_location);
+      profile_, extension_info_map_.get(), request, new_location);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
     net::URLRequest* request,
     int net_error) {
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, net_error);
+      profile_, extension_info_map_.get(), request, net_error);
   ForwardProxyErrors(request, net_error);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnCompleted(net::URLRequest* request,
                                                       bool started,
                                                       int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
   if (net_error != net::OK) {
     ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
-        profile_, extension_info_map_.get(),
-        GetExtensionNavigationUIData(request), request, started, net_error);
+        profile_, extension_info_map_.get(), request, started, net_error);
     return;
   }
 
   bool is_redirect = request->response_headers() &&
                      net::HttpResponseHeaders::IsRedirectResponseCode(
                          request->response_headers()->response_code());
   if (!is_redirect) {
     ExtensionWebRequestEventRouter::GetInstance()->OnCompleted(
-        profile_, extension_info_map_.get(),
-        GetExtensionNavigationUIData(request), request, net_error);
+        profile_, extension_info_map_.get(), request, net_error);
   }
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnURLRequestDestroyed(
     net::URLRequest* request) {
   ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestDestroyed(
       profile_, request);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnPACScriptError(
     int line_number,
     const base::string16& error) {
   extensions::ProxyEventRouter::GetInstance()->OnPACScriptError(
       event_router_.get(), profile_, line_number, error);
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ChromeExtensionsNetworkDelegateImpl::OnAuthRequired(
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     net::AuthCredentials* credentials) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnAuthRequired(
-      profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request, auth_info, callback,
+      profile_, extension_info_map_.get(), request, auth_info, callback,
       credentials);
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_EXTENSIONS)
 
 // static
 ChromeExtensionsNetworkDelegate* ChromeExtensionsNetworkDelegate::Create(
     extensions::EventRouterForwarder* event_router) {
@@ skipping 79 matching lines @@
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ChromeExtensionsNetworkDelegate::OnAuthRequired(
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     net::AuthCredentials* credentials) {
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }