Allow a preconnecting job to a HTTP2 proxy server based on privacy mode

net/http/http_stream_factory_impl.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 "net/http/http_stream_factory_impl.h"
 
 #include <string>
+#include <tuple>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_job_controller.h"
@@ skipping 218 matching lines @@
   for (auto it = job_controller_set_.begin(); it != job_controller_set_.end();
        ++it) {
     if (it->get() == controller) {
       job_controller_set_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
+HttpStreamFactoryImpl::PreconnectingProxyServer::PreconnectingProxyServer(
+    ProxyServer proxy_server,
+    PrivacyMode privacy_mode)
+    : proxy_server(proxy_server), privacy_mode(privacy_mode) {}
+
+bool HttpStreamFactoryImpl::PreconnectingProxyServer::operator<(
+    const PreconnectingProxyServer& other) const {
+  return std::tie(proxy_server, privacy_mode) <
+         std::tie(other.proxy_server, other.privacy_mode);
+}
+
+bool HttpStreamFactoryImpl::PreconnectingProxyServer::operator==(
+    const PreconnectingProxyServer& other) const {
+  return proxy_server == other.proxy_server &&
+         privacy_mode == other.privacy_mode;
+}
+
 bool HttpStreamFactoryImpl::OnInitConnection(const JobController& controller,
-                                             const ProxyInfo& proxy_info) {
+                                             const ProxyInfo& proxy_info,
+                                             PrivacyMode privacy_mode) {
   if (!controller.is_preconnect()) {
     // Connection initialization can be skipped only for the preconnect jobs.
     return false;
   }
 
   if (!session_->params().restrict_to_one_preconnect_for_proxies ||
       !ProxyServerSupportsPriorities(proxy_info)) {
     return false;
   }
 
+  PreconnectingProxyServer preconnecting_proxy_server(proxy_info.proxy_server(),
+                                                      privacy_mode);
+
   if (base::ContainsKey(preconnecting_proxy_servers_,
-                        proxy_info.proxy_server())) {
+                        preconnecting_proxy_server)) {
     UMA_HISTOGRAM_EXACT_LINEAR("Net.PreconnectSkippedToProxyServers", 1, 2);
     // Skip preconnect to the proxy server since we are already preconnecting
     // (probably via some other job).
     return true;
   }
 
   // Add the proxy server to the set of preconnecting proxy servers.
   // The maximum size of |preconnecting_proxy_servers_|.
   static const size_t kMaxPreconnectingServerSize = 3;
   if (preconnecting_proxy_servers_.size() >= kMaxPreconnectingServerSize) {
     // Erase the first entry. A better approach (at the cost of higher memory
     // overhead) may be to erase the least recently used entry.
     preconnecting_proxy_servers_.erase(preconnecting_proxy_servers_.begin());
   }
 
-  preconnecting_proxy_servers_.insert(proxy_info.proxy_server());
+  preconnecting_proxy_servers_.insert(preconnecting_proxy_server);
   DCHECK_GE(kMaxPreconnectingServerSize, preconnecting_proxy_servers_.size());
   // The first preconnect should be allowed.
   return false;
 }
 
-void HttpStreamFactoryImpl::OnStreamReady(const ProxyInfo& proxy_info) {
+void HttpStreamFactoryImpl::OnStreamReady(const ProxyInfo& proxy_info,
+                                          PrivacyMode privacy_mode) {
   if (proxy_info.is_empty())
     return;
-  preconnecting_proxy_servers_.erase(proxy_info.proxy_server());
+  preconnecting_proxy_servers_.erase(
+      PreconnectingProxyServer(proxy_info.proxy_server(), privacy_mode));
 }
 
 bool HttpStreamFactoryImpl::ProxyServerSupportsPriorities(
     const ProxyInfo& proxy_info) const {
   if (proxy_info.is_empty() || !proxy_info.proxy_server().is_valid())
     return false;
 
   if (!proxy_info.proxy_server().is_https())
     return false;
 
   HostPortPair host_port_pair = proxy_info.proxy_server().host_port_pair();
   DCHECK(!host_port_pair.IsEmpty());
 
   url::SchemeHostPort scheme_host_port("https", host_port_pair.host(),
                                        host_port_pair.port());
 
   return session_->http_server_properties()->SupportsRequestPriority(
       scheme_host_port);
 }
 
 }  // namespace net