PlzNavigate: support the WebRequest API

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"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/renderer_host/chrome_navigation_ui_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/browser/api/web_request/web_request_api.h"
+#include "extensions/browser/extension_navigation_ui_data.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/constants.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::ExtensionWebRequestEventRouter;
 
 namespace {
@@ skipping 44 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) override;
@@ skipping 74 matching lines @@
   bool is_nested_url = url.SchemeIsFileSystem() || url.SchemeIsBlob();
   bool is_navigation =
       info && content::IsResourceTypeFrame(info->GetResourceType());
   if (is_nested_url && is_navigation && info->IsMainFrame() &&
       url::Origin(url).scheme() == extensions::kExtensionScheme &&
       !extension_info_map_->process_map().Contains(info->GetChildID())) {
     return net::ERR_ABORTED;
   }
 
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRequest(
-      profile_, extension_info_map_.get(), request, callback, new_url);
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), 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(), request, callback, headers);
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), request, callback, headers);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnStartTransaction(
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   ExtensionWebRequestEventRouter::GetInstance()->OnSendHeaders(
-      profile_, extension_info_map_.get(), request, headers);
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), 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(),
-      request,
-      callback,
-      original_response_headers,
-      override_response_headers,
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), 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(), request, new_location);
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), request, new_location);
 }
 
 
 void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
     net::URLRequest* request) {
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
-      profile_, extension_info_map_.get(), request);
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), request);
   ForwardProxyErrors(request);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnCompleted(
     net::URLRequest* request,
     bool started) {
   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
     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(), request);
+          profile_, extension_info_map_.get(),
+          GetExtensionNavigationUIData(request), request);
     }
     return;
   }
 
   if (request->status().status() == net::URLRequestStatus::FAILED ||
       request->status().status() == net::URLRequestStatus::CANCELED) {
     ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
-        profile_, extension_info_map_.get(), request, started);
+        profile_, extension_info_map_.get(),
+        GetExtensionNavigationUIData(request), request, started);
     return;
   }
 
   NOTREACHED();
 }
 
 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(), request, auth_info, callback,
+      profile_, extension_info_map_.get(),
+      GetExtensionNavigationUIData(request), request, auth_info, callback,
       credentials);
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_EXTENSIONS)
 
 // static
 ChromeExtensionsNetworkDelegate* ChromeExtensionsNetworkDelegate::Create(
     extensions::EventRouterForwarder* event_router) {
@@ skipping 81 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;
 }