Update CPAT protocol to send lite-page transform acceptance with ect

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>
@@ skipping 129 matching lines @@
   bool IsUsingLoFi(const net::URLRequest& request) const override {
     return should_request_lofi_resource_;
   }
 
   void SetIsUsingLoFi(bool should_request_lofi_resource) {
     should_request_lofi_resource_ = should_request_lofi_resource;
   }
 
   void MaybeSetAcceptTransformHeader(
       const net::URLRequest& request,
-      bool is_previews_disabled,
       net::HttpRequestHeaders* headers) const override {
     if (should_request_lofi_resource_) {
       headers->SetHeader(chrome_proxy_accept_transform_header(),
                          empty_image_directive());
     }
   }
 
   bool IsSlowPagePreviewRequested(
       const net::HttpRequestHeaders& headers) const override {
     std::string header_value;
@@ skipping 14 matching lines @@
     return false;
   }
 
   void RemoveAcceptTransformHeader(
       net::HttpRequestHeaders* headers) const override {
     if (ignore_is_using_data_reduction_proxy_check_)
       return;
     headers->RemoveHeader(chrome_proxy_accept_transform_header());
   }
 
-  void MaybeSetIgnorePreviewsBlacklistDirective(
+  void MaybeSetForceLitePageDirective(
       net::HttpRequestHeaders* headers) const override {}
 
-  bool ShouldRecordLoFiUMA(const net::URLRequest& request) const override {
+  bool ShouldRecordPreviewsUMA(const net::URLRequest& request) const override {
     return should_request_lofi_resource_;
   }
 
   void ignore_is_using_data_reduction_proxy_check() {
     ignore_is_using_data_reduction_proxy_check_ = true;
   }
 
  private:
   bool should_request_lofi_resource_;
   bool ignore_is_using_data_reduction_proxy_check_;
@@ skipping 575 matching lines @@
   headers.GetHeader(chrome_proxy_header(), &header_value);
   EXPECT_TRUE(header_value.find("ps=") != std::string::npos);
   EXPECT_TRUE(header_value.find("sid=") != std::string::npos);
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, LoFiTransitions) {
   Init(USE_INSECURE_PROXY, false);
   // Enable Lo-Fi.
   const struct {
     bool lofi_switch_enabled;
-    bool auto_lofi_enabled;
+    bool lofi_field_trial;
     bool is_data_reduction_proxy;
   } tests[] = {
       {
           // Lo-Fi enabled through switch and not using a Data Reduction Proxy.
           true, false, false,
       },
       {
           // Lo-Fi enabled through switch and using a Data Reduction Proxy.
           true, false, true,
       },
       {
           // Lo-Fi enabled through field trial and not using a Data Reduction
           // Proxy.
           false, true, false,
       },
       {
           // Lo-Fi enabled through field trial and using a Data Reduction Proxy.
           false, true, true,
       },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     if (tests[i].lofi_switch_enabled) {
       base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
           switches::kDataReductionProxyLoFi,
           switches::kDataReductionProxyLoFiValueAlwaysOn);
     }
     base::FieldTrialList field_trial_list(nullptr);
-    if (tests[i].auto_lofi_enabled) {
+    if (tests[i].lofi_field_trial) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
-    config()->SetNetworkProhibitivelySlow(tests[i].auto_lofi_enabled);
+    config()->SetNetworkProhibitivelySlow(tests[i].lofi_field_trial);
     io_data()->SetLoFiModeActiveOnMainFrame(false);
 
     net::ProxyInfo data_reduction_proxy_info;
     std::string proxy;
     if (tests[i].is_data_reduction_proxy)
       base::TrimString(params()->DefaultOrigin(), "/", &proxy);
     else
       base::TrimString(kOtherProxy, "/", &proxy);
     data_reduction_proxy_info.UseNamedProxy(proxy);
 
@@ skipping 339 matching lines @@
   histogram_tester.ExpectUniqueSample(kCacheableHistogramName,
                                       kResponseContentLength, 1);
   histogram_tester.ExpectUniqueSample(kCacheable4HoursHistogramName,
                                       kResponseContentLength, 1);
   histogram_tester.ExpectUniqueSample(kCacheable24HoursHistogramName,
                                       kResponseContentLength, 1);
 
   // Check Lo-Fi histograms.
   const struct {
     bool lofi_enabled_through_switch;
-    bool auto_lofi_enabled;
+    bool lofi_field_trial;

[bengr, 2017/05/01 16:53:14]

Does this mean "in the enabled group of the lofi field trial?" 

     int expected_count;
   } tests[] = {
       {
           // Lo-Fi disabled.
           false, false, 0,
       },
       {
-          // Auto Lo-Fi enabled.
+          // Lo-Fi enabled by field trial.
           // This should populate Lo-Fi content length histogram.
           false, true, 1,
       },
       {
           // Lo-Fi enabled through switch.
           // This should populate Lo-Fi content length histogram.
           true, false, 1,
       },
       {
-          // Lo-Fi enabled through switch and Auto Lo-Fi also enabled.
+          // Lo-Fi enabled through switch and also field trial.
           // This should populate Lo-Fi content length histogram.
           true, true, 1,
       },
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     config()->ResetLoFiStatusForTest();
-    config()->SetNetworkProhibitivelySlow(tests[i].auto_lofi_enabled);
+    config()->SetNetworkProhibitivelySlow(tests[i].lofi_field_trial);
     base::FieldTrialList field_trial_list(nullptr);
-    if (tests[i].auto_lofi_enabled) {
+    if (tests[i].lofi_field_trial) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
 
     if (tests[i].lofi_enabled_through_switch) {
       base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
           switches::kDataReductionProxyLoFi,
           switches::kDataReductionProxyLoFiValueAlwaysOn);
     }
 
@@ skipping 414 matching lines @@
   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