Adds feature flag for chrome-proxy-ect header (default off)

components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/mock_entropy_provider.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config_test_utils.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_metrics.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_request_options.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.h"
+#include "components/data_reduction_proxy/core/common/data_reduction_proxy_features.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_headers_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_server.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "components/data_reduction_proxy/core/common/lofi_decider.h"
 #include "components/data_reduction_proxy/proto/client_config.pb.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
@@ skipping 176 matching lines @@
     lofi_ui_service_ = lofi_ui_service.get();
     test_context_->io_data()->set_lofi_ui_service(std::move(lofi_ui_service));
 
     context_.set_enable_brotli(enable_brotli_globally);
     context_.set_network_quality_estimator(&test_network_quality_estimator_);
     context_.Init();
 
     test_context_->EnableDataReductionProxyWithSecureProxyCheckSuccess();
   }
 
+  void EnableECTHeader() {
+    feature_list_.InitWithFeatures(
+        {data_reduction_proxy::features::kDataReductionProxyECTHeader}, {});
+  }
+
   // Build the sockets by adding appropriate mock data for
   // |effective_connection_types.size()| number of requests. Data for
   // chrome-Proxy-ect header is added to the mock data if |expect_ect_header|
   // is true. |reads_list|, |mock_writes| and |writes_list| should be empty, and
   // are owned by the caller.
   void BuildSocket(const std::string& response_headers,
                    const std::string& response_body,
                    bool expect_ect_header,
                    const std::vector<net::EffectiveConnectionType>&
                        effective_connection_types,
@@ skipping 177 matching lines @@
                                      .append(
                                          " HTTP/1.1\r\n"
                                          "Host: ")
                                      .append(host)
                                      .append(
                                          "\r\n"
                                          "Proxy-Connection: keep-alive\r\n"
                                          "User-Agent:\r\n");
 
     std::string accept_language_header("Accept-Language: en-us,fr\r\n");
-    std::string ect_header = "chrome-proxy-ect: " +
-                             std::string(net::GetNameForEffectiveConnectionType(
-                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)) +
-                             "\r\n";
+
+    std::string ect_header;
+    if (data_reduction_proxy::features::
+            IsDataReductionProxyECTHeaderEnabled()) {
+      ect_header = "chrome-proxy-ect: " +
+                   std::string(net::GetNameForEffectiveConnectionType(
+                       net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)) +
+                   "\r\n";
+    }
 
     // Brotli is included in accept-encoding header only if the request went
     // to the network (i.e., it was not a cached response), and if data
     // reduction ptroxy network delegate added Brotli to the header.
     std::string accept_encoding_header =
         expect_brotli && !expect_cached
             ? "Accept-Encoding: gzip, deflate, br\r\n"
             : "Accept-Encoding: gzip, deflate\r\n";
 
     std::string suffix_headers =
@@ skipping 158 matching lines @@
   net::TestNetworkQualityEstimator* test_network_quality_estimator() {
     return &test_network_quality_estimator_;
   }
 
  private:
   base::MessageLoopForIO message_loop_;
   net::MockClientSocketFactory mock_socket_factory_;
   std::unique_ptr<net::ProxyService> proxy_service_;
   net::TestURLRequestContext context_;
   net::URLRequestContextStorage context_storage_;
+  base::test::ScopedFeatureList feature_list_;
 
   TestLoFiDecider* lofi_decider_;
   TestLoFiUIService* lofi_ui_service_;
   std::unique_ptr<DataReductionProxyTestContext> test_context_;
   net::TestNetworkQualityEstimator test_network_quality_estimator_;
 
   net::SSLSocketDataProvider ssl_socket_data_provider_;
 
   std::unique_ptr<net::StaticSocketDataProvider> socket_;
 
@@ skipping 664 matching lines @@
 
   FetchURLRequestAndVerifyBrotli(nullptr, response_headers, false, true);
   FetchURLRequestAndVerifyBrotli(nullptr, response_headers, true, true);
 }
 
 // Test that effective connection type is correctly added to the request
 // headers when it is enabled using field trial. The server is varying on the
 // effective connection type (ECT).
 TEST_F(DataReductionProxyNetworkDelegateTest, ECTHeaderEnabledWithVary) {
   Init(true /* use_secure_proxy */, false /* enable_brotli_globally */);
+  EnableECTHeader();
 
   std::string response_headers =
       "HTTP/1.1 200 OK\r\n"
       "Content-Length: 140\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n"
       "Cache-Control: max-age=1200\r\n"
       "Vary: chrome-proxy-ect\r\n"
       "x-original-content-length: 200\r\n\r\n";
 
   int response_body_size = 140;
   std::string response_body(base::checked_cast<size_t>(response_body_size),
                             ' ');
 
   std::vector<net::MockRead> reads_list;
   std::vector<std::string> mock_writes;
   std::vector<net::MockWrite> writes_list;
 
   std::vector<net::EffectiveConnectionType> effective_connection_types;
   effective_connection_types.push_back(net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   effective_connection_types.push_back(net::EFFECTIVE_CONNECTION_TYPE_2G);
 
-  BuildSocket(response_headers, response_body, true, effective_connection_types,
-              &reads_list, &mock_writes, &writes_list);
+  BuildSocket(response_headers, response_body, true /* expect_ect_header */,
+              effective_connection_types, &reads_list, &mock_writes,
+              &writes_list);
 
   // Add 2 socket providers since 2 requests in this test are fetched from the
   // network.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[0], true, false);
 
   // When the ECT is set to the same value, fetching the same resource should
   // result in a cache hit.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[0], true, true);
 
   // When the ECT is set to a different value, the response should not be
   // served from the cache.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[1], true, false);
 }
 
 // Test that effective connection type is correctly added to the request
 // headers when it is enabled using field trial. The server is not varying on
 // the effective connection type (ECT).
 TEST_F(DataReductionProxyNetworkDelegateTest, ECTHeaderEnabledWithoutVary) {
   Init(true /* use_secure_proxy */, false /* enable_brotli_globally */);
+  EnableECTHeader();
 
   std::string response_headers =
       "HTTP/1.1 200 OK\r\n"
       "Content-Length: 140\r\n"
       "Via: 1.1 Chrome-Compression-Proxy\r\n"
       "Cache-Control: max-age=1200\r\n"
       "x-original-content-length: 200\r\n\r\n";
 
   int response_body_size = 140;
   std::string response_body(base::checked_cast<size_t>(response_body_size),
                             ' ');
 
   std::vector<net::MockRead> reads_list;
   std::vector<std::string> mock_writes;
   std::vector<net::MockWrite> writes_list;
 
   std::vector<net::EffectiveConnectionType> effective_connection_types;
   effective_connection_types.push_back(net::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   effective_connection_types.push_back(net::EFFECTIVE_CONNECTION_TYPE_2G);
 
-  BuildSocket(response_headers, response_body, true, effective_connection_types,
-              &reads_list, &mock_writes, &writes_list);
+  BuildSocket(response_headers, response_body, true /* expect_ect_header */,
+              effective_connection_types, &reads_list, &mock_writes,
+              &writes_list);
 
   // Add 1 socket provider since 1 request in this test is fetched from the
   // network.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[0], true, false);
 
   // When the ECT is set to the same value, fetching the same resource should
   // result in a cache hit.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[0], true, true);
 
   // When the ECT is set to a different value, the response should still be
   // served from the cache.
   FetchURLRequestAndVerifyECTHeader(effective_connection_types[1], true, true);
 }
 
 }  // namespace
 
 }  // namespace data_reduction_proxy