Introduce NetworkDelegate's implementation in extensions.

extensions/browser/extension_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 "extensions/browser/extension_network_delegate.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 "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_system.h"
-#include "extensions/browser/info_map.h"
+#include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/process_manager.h"
 #include "net/url_request/url_request.h"
 
-using content::BrowserThread;
-using content::ResourceRequestInfo;
+namespace extensions {
 
 namespace {
-
-enum RequestStatus { REQUEST_STARTED, REQUEST_DONE };
-
-// Notifies the extensions::ProcessManager that a request has started or stopped
-// for a particular RenderFrame.
-void NotifyEPMRequestStatus(RequestStatus status,
-                            void* profile_id,
-                            int process_id,
-                            int render_frame_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Profile* profile = reinterpret_cast<Profile*>(profile_id);
-  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
-    return;
-
-  extensions::ProcessManager* process_manager =
-      extensions::ExtensionSystem::Get(profile)->process_manager();
-  // This may be NULL in unit tests.
-  if (!process_manager)
-    return;
-
-  // Will be NULL if the request was not issued on behalf of a renderer (e.g. a
-  // system-level request).
-  content::RenderFrameHost* render_frame_host =
-      content::RenderFrameHost::FromID(process_id, render_frame_id);
-  if (render_frame_host) {
-    if (status == REQUEST_STARTED) {
-      process_manager->OnNetworkRequestStarted(render_frame_host);
-    } else if (status == REQUEST_DONE) {
-      process_manager->OnNetworkRequestDone(render_frame_host);
-    } else {
-      NOTREACHED();
-    }
-  }
+bool g_accept_all_cookies = true;
 }
 
-void ForwardRequestStatus(
-    RequestStatus status, net::URLRequest* request, void* profile_id) {
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  if (!info)
-    return;
-
-  if (status == REQUEST_STARTED && request->url_chain().size() > 1) {
-    // It's a redirect, this request has already been counted.
-    return;
-  }
-
-  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, process_id, render_frame_id));
-  }
+ExtensionNetworkDelegate::ExtensionNetworkDelegate(
+      void* browser_context, InfoMap* extension_info_map) {
+  browser_context_ = browser_context;
+  extension_info_map_ = extension_info_map;
 }
 
-class ChromeExtensionsNetworkDelegateImpl
-    : public ChromeExtensionsNetworkDelegate {
- public:
-  explicit ChromeExtensionsNetworkDelegateImpl(
-      extensions::EventRouterForwarder* event_router);
-  virtual ~ChromeExtensionsNetworkDelegateImpl();
+ExtensionNetworkDelegate::~ExtensionNetworkDelegate() {}
 
- private:
-  // ChromeExtensionsNetworkDelegate implementation.
-  virtual void ForwardProxyErrors(net::URLRequest* request) OVERRIDE;
-  virtual void ForwardStartRequestStatus(net::URLRequest* request) OVERRIDE;
-  virtual void ForwardDoneRequestStatus(net::URLRequest* request) OVERRIDE;
-  virtual int OnBeforeURLRequest(net::URLRequest* request,
-                                 const net::CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE;
-  virtual int OnBeforeSendHeaders(net::URLRequest* request,
-                                  const net::CompletionCallback& callback,
-                                  net::HttpRequestHeaders* headers) OVERRIDE;
-  virtual void OnSendHeaders(net::URLRequest* request,
-                             const net::HttpRequestHeaders& headers) OVERRIDE;
-  virtual int 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) OVERRIDE;
-  virtual void OnBeforeRedirect(net::URLRequest* request,
-                                const GURL& new_location) OVERRIDE;
-  virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
-  virtual void OnCompleted(net::URLRequest* request, bool started) OVERRIDE;
-  virtual void OnURLRequestDestroyed(net::URLRequest* request) OVERRIDE;
-  virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE;
-  virtual net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(
-      net::URLRequest* request,
-      const net::AuthChallengeInfo& auth_info,
-      const AuthCallback& callback,
-      net::AuthCredentials* credentials) OVERRIDE;
-
-  scoped_refptr<extensions::EventRouterForwarder> event_router_;
-
-  DISALLOW_COPY_AND_ASSIGN(ChromeExtensionsNetworkDelegateImpl);
-};
-
-ChromeExtensionsNetworkDelegateImpl::ChromeExtensionsNetworkDelegateImpl(
-    extensions::EventRouterForwarder* event_router) {
-  DCHECK(event_router);
-  event_router_ = event_router;
+void ExtensionNetworkDelegate::SetAcceptAllCookies(bool accept) {
+  g_accept_all_cookies = accept;
 }
 
-ChromeExtensionsNetworkDelegateImpl::~ChromeExtensionsNetworkDelegateImpl() {}
-
-void ChromeExtensionsNetworkDelegateImpl::ForwardProxyErrors(
-    net::URLRequest* request) {
-  if (request->status().status() == net::URLRequestStatus::FAILED) {
-    switch (request->status().error()) {
-      case net::ERR_PROXY_AUTH_UNSUPPORTED:
-      case net::ERR_PROXY_CONNECTION_FAILED:
-      case net::ERR_TUNNEL_CONNECTION_FAILED:
-        extensions::ProxyEventRouter::GetInstance()->OnProxyError(
-            event_router_.get(), profile_, request->status().error());
-    }
-  }
-}
-
-void ChromeExtensionsNetworkDelegateImpl::ForwardStartRequestStatus(
-    net::URLRequest* request) {
-  ForwardRequestStatus(REQUEST_STARTED, request, profile_);
-}
-
-void ChromeExtensionsNetworkDelegateImpl::ForwardDoneRequestStatus(
-    net::URLRequest* request) {
-  ForwardRequestStatus(REQUEST_DONE, request, profile_);
-}
-
-int ChromeExtensionsNetworkDelegateImpl::OnBeforeURLRequest(
+int ExtensionNetworkDelegate::OnBeforeURLRequest(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRequest(
-      profile_, extension_info_map_.get(), request, callback, new_url);
+      browser_context_, extension_info_map_.get(), request, callback, new_url);
 }
 
-int ChromeExtensionsNetworkDelegateImpl::OnBeforeSendHeaders(
+int ExtensionNetworkDelegate::OnBeforeSendHeaders(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeSendHeaders(
-      profile_, extension_info_map_.get(), request, callback, headers);
+      browser_context_, extension_info_map_.get(), request, callback, headers);
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnSendHeaders(
+void ExtensionNetworkDelegate::OnSendHeaders(
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
   ExtensionWebRequestEventRouter::GetInstance()->OnSendHeaders(
-      profile_, extension_info_map_.get(), request, headers);
+      browser_context_, extension_info_map_.get(), request, headers);
 }
 
-int ChromeExtensionsNetworkDelegateImpl::OnHeadersReceived(
+int ExtensionNetworkDelegate::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_,
+      browser_context_,
       extension_info_map_.get(),
       request,
       callback,
       original_response_headers,
       override_response_headers,
       allowed_unsafe_redirect_url);
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnBeforeRedirect(
+void ExtensionNetworkDelegate::OnBeforeRedirect(
     net::URLRequest* request,
     const GURL& new_location) {
   ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
-      profile_, extension_info_map_.get(), request, new_location);
+      browser_context_, extension_info_map_.get(), request, new_location);
 }
 
 
-void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
+void ExtensionNetworkDelegate::OnResponseStarted(
     net::URLRequest* request) {
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
-      profile_, extension_info_map_.get(), request);
-  ForwardProxyErrors(request);
+      browser_context_, extension_info_map_.get(), request);
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnCompleted(
+void ExtensionNetworkDelegate::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);
+          browser_context_, extension_info_map_.get(), 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);
+        browser_context_, extension_info_map_.get(), request, started);
     return;
   }
 
   NOTREACHED();
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnURLRequestDestroyed(
+void ExtensionNetworkDelegate::OnURLRequestDestroyed(
     net::URLRequest* request) {
   ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestDestroyed(
-      profile_, request);
+      browser_context_, request);
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnPACScriptError(
+void ExtensionNetworkDelegate::OnPACScriptError(
     int line_number,
     const base::string16& error) {
-  extensions::ProxyEventRouter::GetInstance()->OnPACScriptError(
-      event_router_.get(), profile_, line_number, error);
 }
 
 net::NetworkDelegate::AuthRequiredResponse
-ChromeExtensionsNetworkDelegateImpl::OnAuthRequired(
+ExtensionNetworkDelegate::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,
+      browser_context_, extension_info_map_.get(), request, auth_info, callback,
       credentials);
 }
 
-}  // namespace
-
-#endif  // defined(ENABLE_EXTENSIONS)
-
-// static
-ChromeExtensionsNetworkDelegate* ChromeExtensionsNetworkDelegate::Create(
-    extensions::EventRouterForwarder* event_router) {
-#if defined(ENABLE_EXTENSIONS)
-  return new ChromeExtensionsNetworkDelegateImpl(event_router);
-#else
-  return new ChromeExtensionsNetworkDelegate();
-#endif
-}
-
-ChromeExtensionsNetworkDelegate::ChromeExtensionsNetworkDelegate()
-    : profile_(NULL) {
-}
-
-ChromeExtensionsNetworkDelegate::~ChromeExtensionsNetworkDelegate() {}
-
-void ChromeExtensionsNetworkDelegate::set_extension_info_map(
-    extensions::InfoMap* extension_info_map) {
-#if defined(ENABLE_EXTENSIONS)
-  extension_info_map_ = extension_info_map;
-#endif
-}
-
-void ChromeExtensionsNetworkDelegate::ForwardProxyErrors(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::ForwardStartRequestStatus(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::ForwardDoneRequestStatus(
-    net::URLRequest* request) {
-}
-
-int ChromeExtensionsNetworkDelegate::OnBeforeURLRequest(
-    net::URLRequest* request,
-    const net::CompletionCallback& callback,
-    GURL* new_url) {
-  return net::OK;
-}
-
-int ChromeExtensionsNetworkDelegate::OnBeforeSendHeaders(
-    net::URLRequest* request,
-    const net::CompletionCallback& callback,
-    net::HttpRequestHeaders* headers) {
-  return net::OK;
-}
-
-void ChromeExtensionsNetworkDelegate::OnSendHeaders(
-    net::URLRequest* request,
-    const net::HttpRequestHeaders& headers) {
-}
-
-int ChromeExtensionsNetworkDelegate::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 net::OK;
-}
-
-void ChromeExtensionsNetworkDelegate::OnBeforeRedirect(
-    net::URLRequest* request,
-    const GURL& new_location) {
-}
-
-
-void ChromeExtensionsNetworkDelegate::OnResponseStarted(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::OnCompleted(
-    net::URLRequest* request,
-    bool started) {
-}
-
-void ChromeExtensionsNetworkDelegate::OnURLRequestDestroyed(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::OnPACScriptError(
-    int line_number,
-    const base::string16& error) {
-}
-
-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;
-}
+}  // namespace extensions