Return chrome-proxy-ect header code (post M59 branch)

components/data_reduction_proxy/core/browser/data_reduction_proxy_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 "components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_configurator.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options.h"
 #include "components/data_reduction_proxy/core/browser/data_use_group.h"
 #include "components/data_reduction_proxy/core/browser/data_use_group_provider.h"
+#include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_util.h"
 #include "components/data_reduction_proxy/core/common/lofi_decider.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
+#include "net/nqe/effective_connection_type.h"
 #include "net/nqe/network_quality_estimator.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace data_reduction_proxy {
@@ skipping 90 matching lines @@
          util::CalculateEffectiveOCL(request);
 }
 
 // Verifies that the chrome proxy related request headers are set correctly.
 // |via_chrome_proxy| is true if the request is being fetched via Chrome Data
 // Saver proxy.
 void VerifyHttpRequestHeaders(bool via_chrome_proxy,
                               const net::HttpRequestHeaders& headers) {
   if (via_chrome_proxy) {
     DCHECK(headers.HasHeader(chrome_proxy_header()));
+    DCHECK(headers.HasHeader(chrome_proxy_ect_header()));
   } else {
     DCHECK(!headers.HasHeader(chrome_proxy_header()));
     DCHECK(!headers.HasHeader(chrome_proxy_accept_transform_header()));
+    DCHECK(!headers.HasHeader(chrome_proxy_ect_header()));
   }
 }
 
 }  // namespace
 
 DataReductionProxyNetworkDelegate::DataReductionProxyNetworkDelegate(
     std::unique_ptr<net::NetworkDelegate> network_delegate,
     DataReductionProxyConfig* config,
     DataReductionProxyRequestOptions* request_options,
     const DataReductionProxyConfigurator* configurator)
@@ skipping 64 matching lines @@
     // |request|.
     data_reduction_proxy_io_data_->resource_type_provider()->SetContentType(
         *request);
   }
 
   if (data_reduction_proxy_io_data_->lofi_decider()) {
     data_reduction_proxy_io_data_->lofi_decider()
         ->MaybeSetAcceptTransformHeader(
             *request, data_reduction_proxy_config_->lofi_off(), headers);
   }
+
+  MaybeAddChromeProxyECTHeader(headers, *request);
 }
 
 void DataReductionProxyNetworkDelegate::OnBeforeSendHeadersInternal(
     net::URLRequest* request,
     const net::ProxyInfo& proxy_info,
     const net::ProxyRetryInfoMap& proxy_retry_info,
     net::HttpRequestHeaders* headers) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(data_reduction_proxy_config_);
   DCHECK(request);
@@ skipping 38 matching lines @@
   LoFiDecider* lofi_decider = nullptr;
   if (data_reduction_proxy_io_data_)
     lofi_decider = data_reduction_proxy_io_data_->lofi_decider();
 
   if (!using_data_reduction_proxy) {
     if (lofi_decider) {
       // If not using the data reduction proxy, strip the
       // Chrome-Proxy-Accept-Transform header.
       lofi_decider->RemoveAcceptTransformHeader(headers);
     }
+    RemoveChromeProxyECTHeader(headers);
     VerifyHttpRequestHeaders(false, *headers);
     return;
   }
 
   // Retrieves DataReductionProxyData from a request, creating a new instance
   // if needed.
   data = DataReductionProxyData::GetDataAndCreateIfNecessary(request);
   if (data) {
     data->set_used_data_reduction_proxy(true);
     data->set_session_key(
@@ skipping 273 matching lines @@
   DCHECK_EQ(std::string::npos, header_value.find(kBrotli));
 
   request_headers->RemoveHeader(net::HttpRequestHeaders::kAcceptEncoding);
   if (!header_value.empty())
     header_value += ", ";
   header_value += kBrotli;
   request_headers->SetHeader(net::HttpRequestHeaders::kAcceptEncoding,
                              header_value);
 }
 
+void DataReductionProxyNetworkDelegate::MaybeAddChromeProxyECTHeader(
+    net::HttpRequestHeaders* request_headers,
+    const net::URLRequest& request) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // This method should be called only when the resolved proxy was a data
+  // saver proxy.
+  DCHECK(request.url().is_valid());
+  DCHECK(!request.url().SchemeIsCryptographic());
+  DCHECK(request.url().SchemeIsHTTPOrHTTPS());
+
+  if (request_headers->HasHeader(chrome_proxy_ect_header()))
+    request_headers->RemoveHeader(chrome_proxy_ect_header());
+
+  if (request.context()->network_quality_estimator()) {
+    net::EffectiveConnectionType type = request.context()
+                                            ->network_quality_estimator()
+                                            ->GetEffectiveConnectionType();
+    if (type > net::EFFECTIVE_CONNECTION_TYPE_OFFLINE) {
+      DCHECK_NE(net::EFFECTIVE_CONNECTION_TYPE_LAST, type);
+      request_headers->SetHeader(chrome_proxy_ect_header(),
+                                 net::GetNameForEffectiveConnectionType(type));
+      return;
+    }
+  }
+  request_headers->SetHeader(chrome_proxy_ect_header(),
+                             net::GetNameForEffectiveConnectionType(
+                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN));
+
+  static_assert(net::EFFECTIVE_CONNECTION_TYPE_OFFLINE + 1 ==
+                    net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G,
+                "ECT enum value is not handled.");
+  static_assert(net::EFFECTIVE_CONNECTION_TYPE_4G + 1 ==
+                    net::EFFECTIVE_CONNECTION_TYPE_LAST,
+                "ECT enum value is not handled.");
+}
+
+void DataReductionProxyNetworkDelegate::RemoveChromeProxyECTHeader(
+    net::HttpRequestHeaders* request_headers) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  request_headers->RemoveHeader(chrome_proxy_ect_header());
+}
+
 }  // namespace data_reduction_proxy