DRP: Add check that ECT header is present when CPAT header is present.

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"
@@ skipping 97 matching lines @@
 int64_t EstimateOriginalReceivedBytes(const net::URLRequest& request) {
   if (request.was_cached() || !request.response_headers())
     return request.GetTotalReceivedBytes();
 
   // TODO(sclittle): Remove headers added by Data Reduction Proxy when computing
   // original size. http://crbug/535701.
   return request.response_headers()->raw_headers().size() +
          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,

[megjablon, 2017/03/29 22:20:01]

Capitalize Data Saver?

[tbansal1, 2017/03/29 22:37:54]

Done.

+                              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)
     : LayeredNetworkDelegate(std::move(network_delegate)),
       data_reduction_proxy_config_(config),
       data_reduction_proxy_bypass_stats_(nullptr),
@@ skipping 85 matching lines @@
   DataReductionProxyData::ClearData(request);
 
   if (params::IsIncludedInHoldbackFieldTrial()) {
     if (!WasEligibleWithoutHoldback(*request, proxy_info, proxy_retry_info))
       return;
     // For the holdback field trial, still log UMA as if the proxy was used.
     DataReductionProxyData* data =
         DataReductionProxyData::GetDataAndCreateIfNecessary(request);
     if (data)
       data->set_used_data_reduction_proxy(true);
+    VerifyHttpRequestHeaders(false, *headers);
     return;
   }
 
   bool using_data_reduction_proxy = true;
   // The following checks rule out direct, invalid, and other connection types.
   if (!proxy_info.is_http() && !proxy_info.is_https() &&
       !proxy_info.is_quic()) {
     using_data_reduction_proxy = false;
   } else if (proxy_info.proxy_server().host_port_pair().IsEmpty()) {
     using_data_reduction_proxy = false;
   } else if (!data_reduction_proxy_config_->IsDataReductionProxy(
                  proxy_info.proxy_server(), nullptr)) {
     using_data_reduction_proxy = false;
   }
 
   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.
   DataReductionProxyData* data =
       DataReductionProxyData::GetDataAndCreateIfNecessary(request);
   if (data) {
     data->set_used_data_reduction_proxy(true);
     data->set_session_key(
@@ skipping 16 matching lines @@
 
   if (data) {
     data->set_lofi_requested(
         lofi_decider ? lofi_decider->ShouldRecordLoFiUMA(*request) : false);
   }
   MaybeAddBrotliToAcceptEncodingHeader(proxy_info, headers, *request);
 
   data_reduction_proxy_request_options_->AddRequestHeader(headers);
   if (lofi_decider)
     lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(headers);
+  VerifyHttpRequestHeaders(true, *headers);
 }
 
 void DataReductionProxyNetworkDelegate::OnBeforeRedirectInternal(
     net::URLRequest* request,
     const GURL& new_location) {
   // Since this is after a redirect response, reset |request|'s
   // DataReductionProxyData.
   DataReductionProxyData::ClearData(request);
 }
 
@@ skipping 212 matching lines @@
     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());
 
-  DCHECK(!request_headers->HasHeader(chrome_proxy_ect_header()));
+  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;
@@ skipping 12 matching lines @@
 }
 
 void DataReductionProxyNetworkDelegate::RemoveChromeProxyECTHeader(
     net::HttpRequestHeaders* request_headers) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   request_headers->RemoveHeader(chrome_proxy_ect_header());
 }
 
 }  // namespace data_reduction_proxy