Android: Remove web_request extension API.

chrome/browser/net/chrome_network_delegate.cc

 // Copyright (c) 2012 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_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
-#include "chrome/browser/extensions/api/proxy/proxy_api.h"
-#include "chrome/browser/extensions/api/web_request/web_request_api.h"
-#include "chrome/browser/extensions/event_router_forwarder.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/client_hints.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_metrics.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
 #include "components/domain_reliability/monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/browser/info_map.h"
-#include "extensions/browser/process_manager.h"
 #include "extensions/common/constants.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/io_thread.h"
+#include "components/precache/content/precache_manager.h"
+#include "components/precache/content/precache_manager_factory.h"
+#endif
+
 #if defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "base/sys_info.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #endif
 
-#if defined(OS_ANDROID)
-#include "chrome/browser/io_thread.h"
-#include "components/precache/content/precache_manager.h"
-#include "components/precache/content/precache_manager_factory.h"
-#endif
-
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::ResourceRequestInfo;
 
 // By default we don't allow access to all file:// urls on ChromeOS and
 // Android.
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
 bool ChromeNetworkDelegate::g_allow_file_access_ = false;
 #else
 bool ChromeNetworkDelegate::g_allow_file_access_ = true;
 #endif
 
 // This remains false unless the --disable-extensions-http-throttling
 // flag is passed to the browser.
 bool ChromeNetworkDelegate::g_never_throttle_requests_ = false;
 
 namespace {
 
 const char kDNTHeader[] = "DNT";
 
-// If the |request| failed due to problems with a proxy, forward the error to
-// the proxy extension API.
-void ForwardProxyErrors(net::URLRequest* request,
-                        extensions::EventRouterForwarder* event_router,
-                        void* profile) {
-  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, profile, request->status().error());
-    }
-  }
-}
-
 // Returns whether a URL parameter, |first_parameter| (e.g. foo=bar), has the
 // same key as the the |second_parameter| (e.g. foo=baz). Both parameters
 // must be in key=value form.
 bool HasSameParameterKey(const std::string& first_parameter,
                          const std::string& second_parameter) {
   DCHECK(second_parameter.find("=") != std::string::npos);
   // Prefix for "foo=bar" is "foo=".
   std::string parameter_prefix = second_parameter.substr(
       0, second_parameter.find("=") + 1);
   return StartsWithASCII(first_parameter, parameter_prefix, false);
@@ skipping 49 matching lines @@
 void ForceGoogleSafeSearchCallbackWrapper(
     const net::CompletionCallback& callback,
     net::URLRequest* request,
     GURL* new_url,
     int rv) {
   if (rv == net::OK && new_url->is_empty())
     ForceGoogleSafeSearch(request, new_url);
   callback.Run(rv);
 }
 
-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();
-    }
-  }
-}
-
-void ForwardRequestStatus(
-    RequestStatus status, net::URLRequest* request, void* profile_id) {
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  if (!info)
-    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));
-  }
-}
-
 void UpdateContentLengthPrefs(
     int received_content_length,
     int original_content_length,
     data_reduction_proxy::DataReductionProxyRequestType request_type,
     Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_GE(received_content_length, 0);
   DCHECK_GE(original_content_length, 0);
 
   // Can be NULL in a unit test.
@@ skipping 107 matching lines @@
       g_browser_process->io_thread()->creation_time();
   UMA_HISTOGRAM_TIMES("Net.IOThreadCreationToHTTPRequestStart", request_lag);
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers)
-    : event_router_(event_router),
-      profile_(NULL),
+    : profile_(NULL),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(NULL),
       force_google_safe_search_(NULL),
+#if defined(ENABLE_CONFIGURATION_POLICY)
       url_blacklist_manager_(NULL),
+#endif
       domain_reliability_monitor_(NULL),
       received_content_length_(0),
       original_content_length_(0),
       first_request_(true),
       prerender_tracker_(NULL),
       data_reduction_proxy_params_(NULL) {
-  DCHECK(event_router);
   DCHECK(enable_referrers);
+  extensions_delegate_.reset(
+      ChromeExtensionsNetworkDelegate::Create(event_router));
 }
 
 ChromeNetworkDelegate::~ChromeNetworkDelegate() {}
 
 void ChromeNetworkDelegate::set_extension_info_map(
     extensions::InfoMap* extension_info_map) {
-  extension_info_map_ = extension_info_map;
+  extensions_delegate_->set_extension_info_map(extension_info_map);
+}
+
+void ChromeNetworkDelegate::set_profile(void* profile) {
+  profile_ = profile;
+  extensions_delegate_->set_profile(profile);
 }
 
 void ChromeNetworkDelegate::set_cookie_settings(
     CookieSettings* cookie_settings) {
   cookie_settings_ = cookie_settings;
 }
 
 void ChromeNetworkDelegate::set_predictor(
     chrome_browser_net::Predictor* predictor) {
   connect_interceptor_.reset(
@@ skipping 98 matching lines @@
       url_blacklist_manager_->IsRequestBlocked(*request, &error)) {
     // URL access blocked by policy.
     request->net_log().AddEvent(
         net::NetLog::TYPE_CHROME_POLICY_ABORTED_REQUEST,
         net::NetLog::StringCallback("url",
                                     &request->url().possibly_invalid_spec()));
     return error;
   }
 #endif
 
-  ForwardRequestStatus(REQUEST_STARTED, request, profile_);
+  extensions_delegate_->ForwardStartRequestStatus(request);
 
   if (!enable_referrers_->GetValue())
     request->SetReferrer(std::string());
   if (enable_do_not_track_ && enable_do_not_track_->GetValue())
     request->SetExtraRequestHeaderByName(kDNTHeader, "1", true /* override */);
 
   if (client_hints_) {
     request->SetExtraRequestHeaderByName(
         ClientHints::kDevicePixelRatioHeader,
         client_hints_->GetDevicePixelRatioHeader(), true);
   }
 
   bool force_safe_search = force_google_safe_search_ &&
                            force_google_safe_search_->GetValue();
 
   net::CompletionCallback wrapped_callback = callback;
   if (force_safe_search) {
     wrapped_callback = base::Bind(&ForceGoogleSafeSearchCallbackWrapper,
                                   callback,
                                   base::Unretained(request),
                                   base::Unretained(new_url));
   }
 
-  int rv = ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRequest(
-      profile_, extension_info_map_.get(), request, wrapped_callback,
-      new_url);
+  int rv = extensions_delegate_->OnBeforeURLRequest(
+      request, wrapped_callback, new_url);
 
   if (force_safe_search && rv == net::OK && new_url->is_empty())
     ForceGoogleSafeSearch(request, new_url);
 
   if (connect_interceptor_)
     connect_interceptor_->WitnessURLRequest(request);
 
   return rv;
 }
 
 int ChromeNetworkDelegate::OnBeforeSendHeaders(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   TRACE_EVENT_ASYNC_STEP_PAST0("net", "URLRequest", request, "SendRequest");
-  return ExtensionWebRequestEventRouter::GetInstance()->OnBeforeSendHeaders(
-      profile_, extension_info_map_.get(), request, callback, headers);
+  return extensions_delegate_->OnBeforeSendHeaders(request, callback, headers);
 }
 
 void ChromeNetworkDelegate::OnSendHeaders(
     net::URLRequest* request,
     const net::HttpRequestHeaders& headers) {
-  ExtensionWebRequestEventRouter::GetInstance()->OnSendHeaders(
-      profile_, extension_info_map_.get(), request, headers);
+  extensions_delegate_->OnSendHeaders(request, headers);
 }
 
 int ChromeNetworkDelegate::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) {
-
   if (data_reduction_proxy::MaybeBypassProxyAndPrepareToRetry(
       data_reduction_proxy_params_,
       request,
       original_response_headers,
       override_response_headers)) {
     return net::OK;
   }
 
-  return ExtensionWebRequestEventRouter::GetInstance()->OnHeadersReceived(
-      profile_,
-      extension_info_map_.get(),
+  return extensions_delegate_->OnHeadersReceived(
       request,
       callback,
       original_response_headers,
       override_response_headers,
       allowed_unsafe_redirect_url);
 }
 
 void ChromeNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
                                              const GURL& new_location) {
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnBeforeRedirect(request);
-  ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
-      profile_, extension_info_map_.get(), request, new_location);
+  extensions_delegate_->OnBeforeRedirect(request, new_location);
 }
 
 
 void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
   TRACE_EVENT_ASYNC_STEP_PAST0("net", "URLRequest", request, "ResponseStarted");
-  ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
-      profile_, extension_info_map_.get(), request);
-  ForwardProxyErrors(request, event_router_.get(), profile_);
+  extensions_delegate_->OnResponseStarted(request);
 }
 
 void ChromeNetworkDelegate::OnRawBytesRead(const net::URLRequest& request,
                                            int bytes_read) {
   TRACE_EVENT_ASYNC_STEP_PAST1("net", "URLRequest", &request, "DidRead",
                                "bytes_read", bytes_read);
   performance_monitor::PerformanceMonitor::GetInstance()->BytesReadOnIOThread(
       request, bytes_read);
 
 #if defined(ENABLE_TASK_MANAGER)
@@ skipping 50 matching lines @@
                               request_type);
       RecordContentLengthHistograms(received_content_length,
                                     original_content_length,
                                     freshness_lifetime);
       DVLOG(2) << __FUNCTION__
           << " received content length: " << received_content_length
           << " original content length: " << original_content_length
           << " url: " << request->url();
     }
 
-    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);
-    }
+    extensions_delegate_->OnCompleted(request, started);
   } else if (request->status().status() == net::URLRequestStatus::FAILED ||
              request->status().status() == net::URLRequestStatus::CANCELED) {
-    ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
-            profile_, extension_info_map_.get(), request, started);
+    extensions_delegate_->OnCompleted(request, started);
   } else {
     NOTREACHED();
   }
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnCompleted(request, started);
-  ForwardProxyErrors(request, event_router_.get(), profile_);
-
-  ForwardRequestStatus(REQUEST_DONE, request, profile_);
+  extensions_delegate_->ForwardProxyErrors(request);
+  extensions_delegate_->ForwardDoneRequestStatus(request);
 }
 
 void ChromeNetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {
-  ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestDestroyed(
-      profile_, request);
+  extensions_delegate_->OnURLRequestDestroyed(request);
 }
 
 void ChromeNetworkDelegate::OnPACScriptError(int line_number,
                                              const base::string16& error) {
-  extensions::ProxyEventRouter::GetInstance()->OnPACScriptError(
-      event_router_.get(), profile_, line_number, error);
+  extensions_delegate_->OnPACScriptError(line_number, error);
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ChromeNetworkDelegate::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, credentials);
+  return extensions_delegate_->OnAuthRequired(
+      request, auth_info, callback, credentials);
 }
 
 bool ChromeNetworkDelegate::OnCanGetCookies(
     const net::URLRequest& request,
     const net::CookieList& cookie_list) {
   // NULL during tests, or when we're running in the system context.
   if (!cookie_settings_.get())
     return true;
 
   bool allow = cookie_settings_->IsReadingCookieAllowed(
@@ skipping 121 matching lines @@
     }
   }
 
   DVLOG(1) << "File access denied - " << path.value().c_str();
   return false;
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 }
 
 bool ChromeNetworkDelegate::OnCanThrottleRequest(
     const net::URLRequest& request) const {
-  if (g_never_throttle_requests_) {
+  if (g_never_throttle_requests_)
     return false;
-  }
-
   return request.first_party_for_cookies().scheme() ==
       extensions::kExtensionScheme;
 }
 
 bool ChromeNetworkDelegate::OnCanEnablePrivacyMode(
     const GURL& url,
     const GURL& first_party_for_cookies) const {
   // NULL during tests, or when we're running in the system context.
   if (!cookie_settings_.get())
     return false;
@@ skipping 29 matching lines @@
     data_reduction_proxy::DataReductionProxyRequestType request_type) {
   DCHECK_GE(received_content_length, 0);
   DCHECK_GE(original_content_length, 0);
   StoreAccumulatedContentLength(received_content_length,
                                 original_content_length,
                                 request_type,
                                 reinterpret_cast<Profile*>(profile_));
   received_content_length_ += received_content_length;
   original_content_length_ += original_content_length;
 }