chrome/browser/net/chrome_extensions_network_delegate.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
   6
   7 #include "net/base/net_errors.h"
   8
   9 #if defined(ENABLE_EXTENSIONS)
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/extensions/api/proxy/proxy_api.h"
  12 #include "chrome/browser/extensions/event_router_forwarder.h"
  13 #include "chrome/browser/profiles/profile_manager.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/browser/render_frame_host.h"
  16 #include "content/public/browser/resource_request_info.h"
  17 #include "extensions/browser/api/web_request/web_request_api.h"
  18 #include "extensions/browser/info_map.h"
  19 #include "extensions/browser/process_manager.h"
  20 #include "net/url_request/url_request.h"
  21
  22 using content::BrowserThread;
  23 using content::ResourceRequestInfo;
  24 using extensions::ExtensionWebRequestEventRouter;
  25
  26 namespace {
  27
  28 enum RequestStatus { REQUEST_STARTED, REQUEST_DONE };
  29
  30 // Notifies the extensions::ProcessManager that a request has started or stopped
  31 // for a particular RenderFrame.
  32 void NotifyEPMRequestStatus(RequestStatus status,
  33                             void* profile_id,
  34                             uint64 request_id,
  35                             int process_id,
  36                             int render_frame_id) {
  37   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  38   Profile* profile = reinterpret_cast<Profile*>(profile_id);
  39   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
  40     return;
  41
  42   extensions::ProcessManager* process_manager =
  43       extensions::ProcessManager::Get(profile);
  44   DCHECK(process_manager);
  45
  46   // Will be NULL if the request was not issued on behalf of a renderer (e.g. a
  47   // system-level request).
  48   content::RenderFrameHost* render_frame_host =
  49       content::RenderFrameHost::FromID(process_id, render_frame_id);
  50   if (render_frame_host) {
  51     if (status == REQUEST_STARTED) {
  52       process_manager->OnNetworkRequestStarted(render_frame_host, request_id);
  53     } else if (status == REQUEST_DONE) {
  54       process_manager->OnNetworkRequestDone(render_frame_host, request_id);
  55     } else {
  56       NOTREACHED();
  57     }
  58   }
  59 }
  60
  61 void ForwardRequestStatus(
  62     RequestStatus status, net::URLRequest* request, void* profile_id) {
  63   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
  64   if (!info)
  65     return;
  66
  67   if (status == REQUEST_STARTED && request->url_chain().size() > 1) {
  68     // It's a redirect, this request has already been counted.
  69     return;
  70   }
  71
  72   int process_id, render_frame_id;
  73   if (info->GetAssociatedRenderFrame(&process_id, &render_frame_id)) {
  74     BrowserThread::PostTask(
  75         BrowserThread::UI, FROM_HERE,
  76         base::Bind(&NotifyEPMRequestStatus, status, profile_id,
  77                    request->identifier(), process_id, render_frame_id));
  78   }
  79 }
  80
  81 class ChromeExtensionsNetworkDelegateImpl
  82     : public ChromeExtensionsNetworkDelegate {
  83  public:
  84   explicit ChromeExtensionsNetworkDelegateImpl(
  85       extensions::EventRouterForwarder* event_router);
  86   ~ChromeExtensionsNetworkDelegateImpl() override;
  87
  88  private:
  89   // ChromeExtensionsNetworkDelegate implementation.
  90   void ForwardProxyErrors(net::URLRequest* request) override;
  91   void ForwardStartRequestStatus(net::URLRequest* request) override;
  92   void ForwardDoneRequestStatus(net::URLRequest* request) override;
  93   int OnBeforeURLRequest(net::URLRequest* request,
  94                          const net::CompletionCallback& callback,
  95                          GURL* new_url) override;
  96   int OnBeforeSendHeaders(net::URLRequest* request,
  97                           const net::CompletionCallback& callback,
  98                           net::HttpRequestHeaders* headers) override;
  99   void OnSendHeaders(net::URLRequest* request,
 100                      const net::HttpRequestHeaders& headers) override;
 101   int OnHeadersReceived(
 102       net::URLRequest* request,
 103       const net::CompletionCallback& callback,
 104       const net::HttpResponseHeaders* original_response_headers,
 105       scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
 106       GURL* allowed_unsafe_redirect_url) override;
 107   void OnBeforeRedirect(net::URLRequest* request,
 108                         const GURL& new_location) override;
 109   void OnResponseStarted(net::URLRequest* request) override;
 110   void OnCompleted(net::URLRequest* request, bool started) override;
 111   void OnURLRequestDestroyed(net::URLRequest* request) override;
 112   void OnURLRequestJobOrphaned(net::URLRequest* request) override;
 113   void OnPACScriptError(int line_number, const base::string16& error) override;
 114   net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(
 115       net::URLRequest* request,
 116       const net::AuthChallengeInfo& auth_info,
 117       const AuthCallback& callback,
 118       net::AuthCredentials* credentials) override;
 119
 120   scoped_refptr<extensions::EventRouterForwarder> event_router_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(ChromeExtensionsNetworkDelegateImpl);
 123 };
 124
 125 ChromeExtensionsNetworkDelegateImpl::ChromeExtensionsNetworkDelegateImpl(
 126     extensions::EventRouterForwarder* event_router) {
 127   DCHECK(event_router);
 128   event_router_ = event_router;
 129 }
 130
 131 ChromeExtensionsNetworkDelegateImpl::~ChromeExtensionsNetworkDelegateImpl() {}
 132
 133 void ChromeExtensionsNetworkDelegateImpl::ForwardProxyErrors(
 134     net::URLRequest* request) {
 135   if (request->status().status() == net::URLRequestStatus::FAILED) {
 136     switch (request->status().error()) {
 137       case net::ERR_PROXY_AUTH_UNSUPPORTED:
 138       case net::ERR_PROXY_CONNECTION_FAILED:
 139       case net::ERR_TUNNEL_CONNECTION_FAILED:
 140         extensions::ProxyEventRouter::GetInstance()->OnProxyError(
 141             event_router_.get(), profile_, request->status().error());
 142     }
 143   }
 144 }
 145
 146 void ChromeExtensionsNetworkDelegateImpl::ForwardStartRequestStatus(
 147     net::URLRequest* request) {
 148   ForwardRequestStatus(REQUEST_STARTED, request, profile_);
 149 }
 150
 151 void ChromeExtensionsNetworkDelegateImpl::ForwardDoneRequestStatus(
 152     net::URLRequest* request) {
 153   ForwardRequestStatus(REQUEST_DONE, request, profile_);
 154 }
 155
 156 int ChromeExtensionsNetworkDelegateImpl::OnBeforeURLRequest(
 157     net::URLRequest* request,
 158     const net::CompletionCallback& callback,
 159     GURL* new_url) {
 160   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRequest(
 161       profile_, extension_info_map_.get(), request, callback, new_url);
 162 }
 163
 164 int ChromeExtensionsNetworkDelegateImpl::OnBeforeSendHeaders(
 165     net::URLRequest* request,
 166     const net::CompletionCallback& callback,
 167     net::HttpRequestHeaders* headers) {
 168   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeSendHeaders(
 169       profile_, extension_info_map_.get(), request, callback, headers);
 170 }
 171
 172 void ChromeExtensionsNetworkDelegateImpl::OnSendHeaders(
 173     net::URLRequest* request,
 174     const net::HttpRequestHeaders& headers) {
 175   ExtensionWebRequestEventRouter::GetInstance()->OnSendHeaders(
 176       profile_, extension_info_map_.get(), request, headers);
 177 }
 178
 179 int ChromeExtensionsNetworkDelegateImpl::OnHeadersReceived(
 180     net::URLRequest* request,
 181     const net::CompletionCallback& callback,
 182     const net::HttpResponseHeaders* original_response_headers,
 183     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
 184     GURL* allowed_unsafe_redirect_url) {
 185   return ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
 186       profile_,
 187       extension_info_map_.get(),
 188       request,
 189       callback,
 190       original_response_headers,
 191       override_response_headers,
 192       allowed_unsafe_redirect_url);
 193 }
 194
 195 void ChromeExtensionsNetworkDelegateImpl::OnBeforeRedirect(
 196     net::URLRequest* request,
 197     const GURL& new_location) {
 198   ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
 199       profile_, extension_info_map_.get(), request, new_location);
 200 }
 201
 202
 203 void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
 204     net::URLRequest* request) {
 205   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
 206       profile_, extension_info_map_.get(), request);
 207   ForwardProxyErrors(request);
 208 }
 209
 210 void ChromeExtensionsNetworkDelegateImpl::OnCompleted(
 211     net::URLRequest* request,
 212     bool started) {
 213   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
 214     bool is_redirect = request->response_headers() &&
 215         net::HttpResponseHeaders::IsRedirectResponseCode(
 216             request->response_headers()->response_code());
 217     if (!is_redirect) {
 218       ExtensionWebRequestEventRouter::GetInstance()->OnCompleted(
 219           profile_, extension_info_map_.get(), request);
 220     }
 221     return;
 222   }
 223
 224   if (request->status().status() == net::URLRequestStatus::FAILED ||
 225       request->status().status() == net::URLRequestStatus::CANCELED) {
 226     ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
 227         profile_, extension_info_map_.get(), request, started);
 228     return;
 229   }
 230
 231   NOTREACHED();
 232 }
 233
 234 void ChromeExtensionsNetworkDelegateImpl::OnURLRequestDestroyed(
 235     net::URLRequest* request) {
 236   ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestDestroyed(
 237       profile_, request);
 238 }
 239
 240 void ChromeExtensionsNetworkDelegateImpl::OnURLRequestJobOrphaned(
 241     net::URLRequest* request) {
 242   ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestJobOrphaned(
 243       profile_, request);
 244 }
 245
 246 void ChromeExtensionsNetworkDelegateImpl::OnPACScriptError(
 247     int line_number,
 248     const base::string16& error) {
 249   extensions::ProxyEventRouter::GetInstance()->OnPACScriptError(
 250       event_router_.get(), profile_, line_number, error);
 251 }
 252
 253 net::NetworkDelegate::AuthRequiredResponse
 254 ChromeExtensionsNetworkDelegateImpl::OnAuthRequired(
 255     net::URLRequest* request,
 256     const net::AuthChallengeInfo& auth_info,
 257     const AuthCallback& callback,
 258     net::AuthCredentials* credentials) {
 259   return ExtensionWebRequestEventRouter::GetInstance()->OnAuthRequired(
 260       profile_, extension_info_map_.get(), request, auth_info, callback,
 261       credentials);
 262 }
 263
 264 }  // namespace
 265
 266 #endif  // defined(ENABLE_EXTENSIONS)
 267
 268 // static
 269 ChromeExtensionsNetworkDelegate* ChromeExtensionsNetworkDelegate::Create(
 270     extensions::EventRouterForwarder* event_router) {
 271 #if defined(ENABLE_EXTENSIONS)
 272   return new ChromeExtensionsNetworkDelegateImpl(event_router);
 273 #else
 274   return new ChromeExtensionsNetworkDelegate();
 275 #endif
 276 }
 277
 278 ChromeExtensionsNetworkDelegate::ChromeExtensionsNetworkDelegate()
 279     : profile_(NULL) {
 280 }
 281
 282 ChromeExtensionsNetworkDelegate::~ChromeExtensionsNetworkDelegate() {}
 283
 284 void ChromeExtensionsNetworkDelegate::set_extension_info_map(
 285     extensions::InfoMap* extension_info_map) {
 286 #if defined(ENABLE_EXTENSIONS)
 287   extension_info_map_ = extension_info_map;
 288 #endif
 289 }
 290
 291 void ChromeExtensionsNetworkDelegate::ForwardProxyErrors(
 292     net::URLRequest* request) {
 293 }
 294
 295 void ChromeExtensionsNetworkDelegate::ForwardStartRequestStatus(
 296     net::URLRequest* request) {
 297 }
 298
 299 void ChromeExtensionsNetworkDelegate::ForwardDoneRequestStatus(
 300     net::URLRequest* request) {
 301 }
 302
 303 int ChromeExtensionsNetworkDelegate::OnBeforeURLRequest(
 304     net::URLRequest* request,
 305     const net::CompletionCallback& callback,
 306     GURL* new_url) {
 307   return net::OK;
 308 }
 309
 310 int ChromeExtensionsNetworkDelegate::OnBeforeSendHeaders(
 311     net::URLRequest* request,
 312     const net::CompletionCallback& callback,
 313     net::HttpRequestHeaders* headers) {
 314   return net::OK;
 315 }
 316
 317 void ChromeExtensionsNetworkDelegate::OnSendHeaders(
 318     net::URLRequest* request,
 319     const net::HttpRequestHeaders& headers) {
 320 }
 321
 322 int ChromeExtensionsNetworkDelegate::OnHeadersReceived(
 323     net::URLRequest* request,
 324     const net::CompletionCallback& callback,
 325     const net::HttpResponseHeaders* original_response_headers,
 326     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
 327     GURL* allowed_unsafe_redirect_url) {
 328   return net::OK;
 329 }
 330
 331 void ChromeExtensionsNetworkDelegate::OnBeforeRedirect(
 332     net::URLRequest* request,
 333     const GURL& new_location) {
 334 }
 335
 336
 337 void ChromeExtensionsNetworkDelegate::OnResponseStarted(
 338     net::URLRequest* request) {
 339 }
 340
 341 void ChromeExtensionsNetworkDelegate::OnCompleted(
 342     net::URLRequest* request,
 343     bool started) {
 344 }
 345
 346 void ChromeExtensionsNetworkDelegate::OnURLRequestDestroyed(
 347     net::URLRequest* request) {
 348 }
 349
 350 void ChromeExtensionsNetworkDelegate::OnURLRequestJobOrphaned(
 351     net::URLRequest* request) {
 352 }
 353
 354 void ChromeExtensionsNetworkDelegate::OnPACScriptError(
 355     int line_number,
 356     const base::string16& error) {
 357 }
 358
 359 net::NetworkDelegate::AuthRequiredResponse
 360 ChromeExtensionsNetworkDelegate::OnAuthRequired(
 361     net::URLRequest* request,
 362     const net::AuthChallengeInfo& auth_info,
 363     const AuthCallback& callback,
 364     net::AuthCredentials* credentials) {
 365   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 366 }