Remove unused network service custom proxy code

This is no longer needed with data reduction proxy being turned off.

This removes the logic for
(i) Adding/removing proxy-specific pre-cache and post-cache headers
(ii) Remembering redirect loops within proxy delegate and disabling
custom proxy on redirect loops.
(iii) Use of alternate proxies for http:// requests (this was a
hack to enable use of QUIC for custom proxies for http:// requests).
(iv) Remembering the last N custom proxy configurations
in proxy delegate.

Change-Id: I4ee0cca48c1d581e026738964cb9e7a27f57a92e
Bug: 1048736
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2101318
Commit-Queue: Tarun Bansal <tbansal@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Robert Ogden <robertogden@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#752486}

chrome/browser/prerender/isolated/isolated_prerender_browsertest.cc

@@ -186,14 +186,6 @@ class IsolatedPrerenderBrowserTest
               net::ProxyConfig::ProxyRules::Type::PROXY_LIST_PER_SCHEME);
     EXPECT_FALSE(config->should_override_existing_config);
     EXPECT_FALSE(config->allow_non_idempotent_methods);
-    EXPECT_FALSE(config->assume_https_proxies_support_quic);
-    EXPECT_TRUE(config->can_use_proxy_on_http_url_redirect_cycles);
-
-    EXPECT_TRUE(config->pre_cache_headers.IsEmpty());
-    EXPECT_TRUE(config->post_cache_headers.IsEmpty());
-
-    EXPECT_EQ(config->rules.proxies_for_http.size(), 0U);
-    EXPECT_EQ(config->rules.proxies_for_ftp.size(), 0U);
 
     if (want_empty) {
       EXPECT_EQ(config->rules.proxies_for_https.size(), 0U);

chrome/browser/prerender/isolated/isolated_prerender_proxy_configurator_unittest.cc

@@ -74,11 +74,7 @@ class IsolatedPrerenderProxyConfiguratorTest : public testing::Test {
               net::ProxyConfig::ProxyRules::Type::PROXY_LIST_PER_SCHEME);
     EXPECT_FALSE(config->should_override_existing_config);
     EXPECT_FALSE(config->allow_non_idempotent_methods);
-    EXPECT_FALSE(config->assume_https_proxies_support_quic);
-    EXPECT_TRUE(config->can_use_proxy_on_http_url_redirect_cycles);
 
-    EXPECT_TRUE(config->pre_cache_headers.IsEmpty());
-    EXPECT_TRUE(config->post_cache_headers.IsEmpty());
     EXPECT_EQ(config->connect_tunnel_headers.ToString(), headers.ToString());
 
     EXPECT_EQ(config->rules.proxies_for_http.size(), 0U);

services/network/network_service_network_delegate.cc

@@ -104,10 +104,6 @@ int NetworkServiceNetworkDelegate::OnBeforeStartTransaction(
     net::URLRequest* request,
     net::CompletionOnceCallback callback,
     net::HttpRequestHeaders* headers) {
-  if (network_context_->proxy_delegate()) {
-    network_context_->proxy_delegate()->OnBeforeStartTransaction(request,
-                                                                 headers);
-  }
   URLLoader* url_loader = URLLoader::ForRequest(*request);
   if (url_loader)
     return url_loader->OnBeforeStartTransaction(std::move(callback), headers);
@@ -126,10 +122,6 @@ void NetworkServiceNetworkDelegate::OnBeforeSendHeaders(
     const net::ProxyInfo& proxy_info,
     const net::ProxyRetryInfoMap& proxy_retry_info,
     net::HttpRequestHeaders* headers) {
-  if (network_context_->proxy_delegate()) {
-    network_context_->proxy_delegate()->OnBeforeSendHeaders(request, proxy_info,
-                                                            headers);
-  }
 }
 
 int NetworkServiceNetworkDelegate::OnHeadersReceived(

services/network/network_service_proxy_delegate.cc

@@ -14,13 +14,6 @@
 namespace network {
 namespace {
 
-// The maximum size of the two caches that contain the GURLs for which special
-// handling is required.
-constexpr size_t kMaxCacheSize = 15;
-
-// The maximum number of previous configs to keep.
-constexpr size_t kMaxPreviousConfigs = 2;
-
 bool ApplyProxyConfigToProxyInfo(const net::ProxyConfig::ProxyRules& rules,
                                  const net::ProxyRetryInfoMap& proxy_retry_info,
                                  const GURL& url,
@@ -98,24 +91,6 @@ void MergeRequestHeaders(net::HttpRequestHeaders* out,
   }
 }
 
-bool IsURLBlockedForCustomProxy(const net::URLRequest& request) {
-  auto* url_loader = URLLoader::ForRequest(request);
-  if (url_loader && url_loader->GetProcessId() == 0 &&
-      static_cast<SpecialRoutingIDs>(url_loader->GetRenderFrameId()) ==
-          MSG_ROUTING_NONE) {
-    // The request is not initiated by navigation or renderer. Block the request
-    // from going through custom proxy. This is a temporary solution to fix the
-    // bypassed downloads when using the custom proxy. See crbug.com/953166.
-    // TODO(957215): Implement a better solution in download manager and remove
-    // this codepath
-    return true;
-  }
-  // If the last entry occurs earlier in the |url_chain|, then very likely there
-  // is a redirect cycle.
-  return std::find(request.url_chain().rbegin() + 1, request.url_chain().rend(),
-                   request.url_chain().back()) != request.url_chain().rend();
-}
-
 }  // namespace
 
 NetworkServiceProxyDelegate::NetworkServiceProxyDelegate(
@@ -130,66 +105,6 @@ NetworkServiceProxyDelegate::NetworkServiceProxyDelegate(
     proxy_config_ = mojom::CustomProxyConfig::New();
 }
 
-void NetworkServiceProxyDelegate::OnBeforeStartTransaction(
-    net::URLRequest* request,
-    net::HttpRequestHeaders* headers) {
-  if (!MayProxyURL(request->url()))
-    return;
-
-  if (!proxy_config_->can_use_proxy_on_http_url_redirect_cycles &&
-      MayHaveProxiedURL(request->url()) &&
-      request->url().SchemeIs(url::kHttpScheme) &&
-      IsURLBlockedForCustomProxy(*request)) {
-    redirect_loop_cache_.push_front(request->url());
-    if (previous_proxy_configs_.size() > kMaxCacheSize)
-      redirect_loop_cache_.pop_back();
-  }
-
-  // For other schemes, the headers can be added to the CONNECT request when
-  // establishing the secure tunnel instead, see OnBeforeHttp1TunnelRequest().
-  const bool scheme_is_http = request->url().SchemeIs(url::kHttpScheme);
-  if (scheme_is_http) {
-    MergeRequestHeaders(headers, proxy_config_->pre_cache_headers);
-    auto* url_loader = URLLoader::ForRequest(*request);
-    if (url_loader) {
-      MergeRequestHeaders(headers,
-                          url_loader->custom_proxy_pre_cache_headers());
-    }
-  }
-}
-
-void NetworkServiceProxyDelegate::OnBeforeSendHeaders(
-    net::URLRequest* request,
-    const net::ProxyInfo& proxy_info,
-    net::HttpRequestHeaders* headers) {
-  // For other schemes, the headers can be added to the CONNECT request when
-  // establishing the secure tunnel instead, see OnBeforeHttp1TunnelRequest().
-  if (!request->url().SchemeIs(url::kHttpScheme))
-    return;
-
-  auto* url_loader = URLLoader::ForRequest(*request);
-
-  if (IsInProxyConfig(proxy_info.proxy_server())) {
-    MergeRequestHeaders(headers, proxy_config_->post_cache_headers);
-
-    if (url_loader) {
-      MergeRequestHeaders(headers,
-                          url_loader->custom_proxy_post_cache_headers());
-    }
-  } else if (MayHaveProxiedURL(request->url())) {
-    for (const auto& kv : proxy_config_->pre_cache_headers.GetHeaderVector()) {
-      headers->RemoveHeader(kv.key);
-    }
-
-    if (url_loader) {
-      for (const auto& kv :
-           url_loader->custom_proxy_pre_cache_headers().GetHeaderVector()) {
-        headers->RemoveHeader(kv.key);
-      }
-    }
-  }
-}
-
 NetworkServiceProxyDelegate::~NetworkServiceProxyDelegate() {}
 
 void NetworkServiceProxyDelegate::OnResolveProxy(
@@ -200,18 +115,11 @@ void NetworkServiceProxyDelegate::OnResolveProxy(
   if (!EligibleForProxy(*result, method))
     return;
 
-  // Check if using custom proxy for |url| can result in redirect loops.
-  std::deque<GURL>::const_iterator it =
-      std::find(redirect_loop_cache_.begin(), redirect_loop_cache_.end(), url);
-  if (it != redirect_loop_cache_.end())
-    return;
-
   net::ProxyInfo proxy_info;
   if (ApplyProxyConfigToProxyInfo(proxy_config_->rules, proxy_retry_info, url,
                                   &proxy_info)) {
     DCHECK(!proxy_info.is_empty() && !proxy_info.is_direct());
     result->OverrideProxyList(proxy_info.proxy_list());
-    GetAlternativeProxy(proxy_retry_info, result);
   }
 }
 
@@ -234,11 +142,6 @@ net::Error NetworkServiceProxyDelegate::OnTunnelHeadersReceived(
 void NetworkServiceProxyDelegate::OnCustomProxyConfigUpdated(
     mojom::CustomProxyConfigPtr proxy_config) {
   DCHECK(IsValidCustomProxyConfig(*proxy_config));
-  if (proxy_config_) {
-    previous_proxy_configs_.push_front(std::move(proxy_config_));
-    if (previous_proxy_configs_.size() > kMaxPreviousConfigs)
-      previous_proxy_configs_.pop_back();
-  }
   proxy_config_ = std::move(proxy_config);
 }
 
@@ -278,12 +181,6 @@ bool NetworkServiceProxyDelegate::IsInProxyConfig(
   if (RulesContainsProxy(proxy_config_->rules, proxy_server))
     return true;
 
-  for (const auto& config : previous_proxy_configs_) {
-    if (RulesContainsProxy(config->rules, proxy_server)) {
-      return true;
-    }
-  }
-
   return false;
 }
 
@@ -291,18 +188,6 @@ bool NetworkServiceProxyDelegate::MayProxyURL(const GURL& url) const {
   return !proxy_config_->rules.empty();
 }
 
-bool NetworkServiceProxyDelegate::MayHaveProxiedURL(const GURL& url) const {
-  if (!proxy_config_->rules.empty())
-    return true;
-
-  for (const auto& config : previous_proxy_configs_) {
-    if (!config->rules.empty())
-      return true;
-  }
-
-  return false;
-}
-
 bool NetworkServiceProxyDelegate::EligibleForProxy(
     const net::ProxyInfo& proxy_info,
     const std::string& method) const {
@@ -319,26 +204,4 @@ bool NetworkServiceProxyDelegate::EligibleForProxy(
   return true;
 }
 
-void NetworkServiceProxyDelegate::GetAlternativeProxy(
-    const net::ProxyRetryInfoMap& proxy_retry_info,
-    net::ProxyInfo* result) {
-  net::ProxyServer resolved_proxy_server = result->proxy_server();
-  DCHECK(resolved_proxy_server.is_valid());
-
-  if (!resolved_proxy_server.is_https() ||
-      !proxy_config_->assume_https_proxies_support_quic) {
-    return;
-  }
-
-  net::ProxyInfo alternative_proxy_info;
-  alternative_proxy_info.UseProxyServer(net::ProxyServer(
-      net::ProxyServer::SCHEME_QUIC, resolved_proxy_server.host_port_pair()));
-  alternative_proxy_info.DeprioritizeBadProxies(proxy_retry_info);
-
-  if (alternative_proxy_info.is_empty())
-    return;
-
-  result->SetAlternativeProxy(alternative_proxy_info.proxy_server());
-}
-
 }  // namespace network

services/network/network_service_proxy_delegate.h

@@ -16,7 +16,6 @@
 namespace net {
 class HttpRequestHeaders;
 class ProxyResolutionService;
-class URLRequest;
 }  // namespace net
 
 namespace network {
@@ -39,13 +38,6 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkServiceProxyDelegate
     proxy_resolution_service_ = proxy_resolution_service;
   }
 
-  // These methods are forwarded from the NetworkDelegate.
-  void OnBeforeStartTransaction(net::URLRequest* request,
-                                net::HttpRequestHeaders* headers);
-  void OnBeforeSendHeaders(net::URLRequest* request,
-                           const net::ProxyInfo& proxy_info,
-                           net::HttpRequestHeaders* headers);
-
   // net::ProxyDelegate implementation:
   void OnResolveProxy(const GURL& url,
                       const std::string& method,
@@ -65,19 +57,11 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkServiceProxyDelegate
   // Whether the current config may proxy |url|.
   bool MayProxyURL(const GURL& url) const;
 
-  // Whether the current config may have proxied |url| with the current config
-  // or a previous config.
-  bool MayHaveProxiedURL(const GURL& url) const;
-
   // Whether the HTTP |method| with current |proxy_info| is eligible to be
   // proxied.
   bool EligibleForProxy(const net::ProxyInfo& proxy_info,
                         const std::string& method) const;
 
-  // Fills the alternative proxy config in |result| if applicable.
-  void GetAlternativeProxy(const net::ProxyRetryInfoMap& proxy_retry_info,
-                           net::ProxyInfo* result);
-
   // mojom::CustomProxyConfigClient implementation:
   void OnCustomProxyConfigUpdated(
       mojom::CustomProxyConfigPtr proxy_config) override;
@@ -89,17 +73,6 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkServiceProxyDelegate
   mojom::CustomProxyConfigPtr proxy_config_;
   mojo::Receiver<mojom::CustomProxyConfigClient> receiver_;
 
-  // Cache of URLs for which the usage of custom proxy results
-  // in redirect loops. A container is used here since it's possible that
-  // at any given time, there are multiple URLs that result in redirect loops
-  // when fetched via the custom proxy.
-  std::deque<GURL> redirect_loop_cache_;
-
-  // We keep track of a limited number of previous configs so we can determine
-  // if a request used a custom proxy if the config happened to change during
-  // the request.
-  std::deque<mojom::CustomProxyConfigPtr> previous_proxy_configs_;
-
   net::ProxyResolutionService* proxy_resolution_service_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkServiceProxyDelegate);

services/network/public/cpp/url_request_mojom_traits.cc

@@ -185,10 +185,6 @@ bool StructTraits<
       !data.ReadFetchIntegrity(&out->fetch_integrity) ||
       !data.ReadRequestBody(&out->request_body) ||
       !data.ReadThrottlingProfileId(&out->throttling_profile_id) ||
-      !data.ReadCustomProxyPreCacheHeaders(
-          &out->custom_proxy_pre_cache_headers) ||
-      !data.ReadCustomProxyPostCacheHeaders(
-          &out->custom_proxy_post_cache_headers) ||
       !data.ReadFetchWindowId(&out->fetch_window_id) ||
       !data.ReadDevtoolsRequestId(&out->devtools_request_id) ||
       !data.ReadRecursivePrefetchToken(&out->recursive_prefetch_token) ||

services/network/public/cpp/url_request_mojom_traits_unittest.cc

@@ -87,8 +87,6 @@ TEST(URLRequestMojomTraitsTest, Roundtrips_ResourceRequest) {
   original.upgrade_if_insecure = true;
   original.is_revalidating = false;
   original.throttling_profile_id = base::UnguessableToken::Create();
-  original.custom_proxy_pre_cache_headers.SetHeader("pre_x", "x_value");
-  original.custom_proxy_post_cache_headers.SetHeader("post_y", "y_value");
   original.fetch_window_id = base::UnguessableToken::Create();
 
   original.trusted_params = ResourceRequest::TrustedParams();

services/network/public/mojom/network_context.mojom

@@ -86,40 +86,6 @@ struct CustomProxyConfig {
   // case properly.
   bool allow_non_idempotent_methods = false;
 
-  // Whether every HTTPS proxy in the custom proxy config can be assumed to
-  // also support QUIC. If this is true, the network service will try to
-  // establish an alternative QUIC stream to the proxy in parallel to the HTTPS
-  // stream in an attempt to use QUIC if possible.
-  bool assume_https_proxies_support_quic = false;
-
-  // Whether the custom proxy config can be used on HTTP URLs whose fetching
-  // causes redirect cycles. If set to false, network service will try to
-  // bypass custom proxies on HTTP requests whose fetching causes redirect
-  // cycles. In such cases, the request will be fetched directly once the
-  // redirect cycle is detected.
-  // TODO(https://crbug.com/945892): Remove this boolean once Network
-  // Servicification is fully launched.
-  bool can_use_proxy_on_http_url_redirect_cycles = true;
-
-  // The custom proxy can set these headers in this config which will be added
-  // to all requests using the proxy. This allows setting headers that may be
-  // privacy/security sensitive which we don't want to send to the renderer.
-  // Headers that require per-request logic can be added through the
-  // |custom_proxy_pre_cache_headers| and |custom_proxy_post_cache_headers|
-  // fields in ResourceRequest.
-  //
-  // Headers that will be set before the cache for http:// requests. If the
-  // request does not use a custom proxy, these headers will be removed before
-  // sending to the network. If a request already has one of these headers set,
-  // it may be overwritten if a custom proxy is used, or removed if a custom
-  // proxy is not used.
-  HttpRequestHeaders pre_cache_headers;
-
-  // Headers that will be set after the cache for http:// requests that are
-  // issued through a custom proxy. Headers here will overwrite matching
-  // headers on the request if a custom proxy is used.
-  HttpRequestHeaders post_cache_headers;
-
   // For tunneled requests (https://, ws://, wss://), these headers are added
   // to the CONNECT request. Headers here will overwrite matching headers on
   // the CONNECT request if a custom proxy is used.

services/network/public/mojom/url_loader.mojom

@@ -347,13 +347,6 @@ struct URLRequest {
   // The profile ID of network conditions to throttle the network request.
   mojo_base.mojom.UnguessableToken? throttling_profile_id;
 
-  // Headers that will be added pre and post cache for http:// requests if the
-  // network context uses the custom proxy for this request. The custom proxy
-  // is used for requests that match the custom proxy config, and would
-  // otherwise be made direct.
-  HttpRequestHeaders custom_proxy_pre_cache_headers;
-  HttpRequestHeaders custom_proxy_post_cache_headers;
-
   // See https://fetch.spec.whatwg.org/#concept-request-window
   //
   // This is an opaque id of the original requestor of the resource, which might