New CPAT support in ContentLoFiDecider guarded by feature flag.

components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc

 // Copyright 2015 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/content/browser/content_lofi_decider.h"
 
 #include <stddef.h>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/scoped_feature_list.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_network_delegate.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_params.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_switches.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/previews_state.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/http/http_request_headers.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 150 matching lines @@
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
     if (expected_if_heavy) {
       std::string lite_page_if_heavy = base::StringPrintf(
           "%s;%s", lite_page_directive(), if_heavy_qualifier());
       EXPECT_EQ(expected_lofi_preview_used, lite_page_if_heavy == header_value);
     } else {
       EXPECT_EQ(expected_lofi_preview_used,
                 header_value == lite_page_directive());
     }
   }
 

[megjablon, 2017/06/01 00:06:21]

Can we move even more of the repetitive code:

static void VerifyAcceptTransformHeader(
    content::ResourceType resource_type,
    bool is_https,
    content::PreviewsState previews_state,
    bool expected_accept_lite_page,
    bool expected_accept_empty_image) {
  std::unique_ptr<net::URLRequest> request =
       CreateRequestByType(resource_type, is_https, previews_state);

  net::HttpRequestHeaders headers;
  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers);

  std::string header_value;
  EXPECT_EQ(expected_accept_lite_page || expected_accept_empty_image,
            headers.GetHeader(chrome_proxy_accept_transform_header(),
&header_value));

  if (expected_accept_lite_page) {
    EXPECT_TRUE(header_value == lite_page_directive());
  } else if (expected_accept_empty_image) {
    EXPECT_TRUE(header_value == empty_image_directive());
  } else {
    EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header()));
  }
}

[dougarnett, 2017/06/01 18:16:48]

Pulling in the target api call helps quite a bit. I went with passing in the
request rather than all the parms for the request so that the tests themselves
are more readable. 

+  static void VerifyAcceptTransformHeader(
+      bool expected_accept_lite_page,
+      bool expected_accept_empty_image,
+      const net::HttpRequestHeaders& headers) {
+    if (expected_accept_lite_page || expected_accept_empty_image) {
+      EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header()));
+      std::string header_value;
+      headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
+      if (expected_accept_lite_page) {
+        EXPECT_TRUE(header_value == lite_page_directive());
+      } else if (expected_accept_empty_image) {
+        EXPECT_TRUE(header_value == empty_image_directive());
+      }
+    } else {
+      EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header()));
+    }
+  }
+
   static void VerifyVideoHeader(bool expected_compressed_video_used,
                                 const net::HttpRequestHeaders& headers) {
     EXPECT_EQ(expected_compressed_video_used,
               headers.HasHeader(chrome_proxy_accept_transform_header()));
     std::string header_value;
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
     EXPECT_EQ(
         expected_compressed_video_used,
         header_value.find(compressed_video_directive()) != std::string::npos);
   }
@@ skipping 94 matching lines @@
     VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi,
                      headers);
     VerifyLitePageHeader(false, false, headers);
     data = DataReductionProxyData::GetData(*request);
     // |lofi_requested| should be set to false when Lo-Fi is enabled using
     // flags.
     EXPECT_FALSE(data->lofi_requested());
   }
 }
 
+TEST_F(ContentLoFiDeciderTest, MaybeSetAcceptTransformNoAcceptForPreviewsOff) {
+  // Turn on proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+
+  content::PreviewsState both_previews_enabled =
+      content::SERVER_LITE_PAGE_ON | content::SERVER_LOFI_ON;
+
+  // Verify no accept header if previews state indicates to not accept.
+  content::PreviewsState previews_off =
+      content::PREVIEWS_OFF & both_previews_enabled;
+  std::unique_ptr<net::URLRequest> request =
+      CreateRequest(true /* is main */, previews_off);
+  net::HttpRequestHeaders headers;
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers);
+
+  content::PreviewsState previews_no_transform =
+      content::PREVIEWS_NO_TRANSFORM & both_previews_enabled;
+  request = CreateRequest(true /* is main */, previews_no_transform);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers);
+}
+
+TEST_F(ContentLoFiDeciderTest, MaybeSetAcceptTransformNoAcceptForHttps) {
+  // Turn on proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+
+  content::PreviewsState both_previews_enabled =
+      content::SERVER_LITE_PAGE_ON | content::SERVER_LOFI_ON;
+
+  // Verify no accept header for HTTPS.
+  std::unique_ptr<net::URLRequest> request =
+      CreateRequestByType(content::RESOURCE_TYPE_MAIN_FRAME, true /* https */,
+                          both_previews_enabled);
+  net::HttpRequestHeaders headers;
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers);
+
+  request = CreateRequestByType(content::RESOURCE_TYPE_IMAGE, true /* https */,
+                                both_previews_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers);
+}
+
+TEST_F(ContentLoFiDeciderTest, MaybeSetAcceptTransformHeaderAcceptLitePage) {
+  // Turn on proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+
+  content::PreviewsState lite_page_enabled = content::SERVER_LITE_PAGE_ON;
+
+  // Verify accepting lite-page per resource type.
+  std::unique_ptr<net::URLRequest> request =
+      CreateRequest(true /* is main */, lite_page_enabled);
+  net::HttpRequestHeaders headers1;
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers1);
+  VerifyAcceptTransformHeader(true /* lite-page */, false /* empty-image */,
+                              headers1);
+
+  net::HttpRequestHeaders headers2;
+  request = CreateRequest(false /* is main */, lite_page_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers2);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers2);
+}
+
+TEST_F(ContentLoFiDeciderTest, MaybeSetAcceptTransformHeaderAcceptEmptyImage) {
+  // Turn on proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+
+  content::PreviewsState lofi_enabled = content::SERVER_LOFI_ON;
+
+  // Verify accepting empty-image per resource type.
+  std::unique_ptr<net::URLRequest> request = CreateRequestByType(
+      content::RESOURCE_TYPE_MAIN_FRAME, false /* https */, lofi_enabled);
+  net::HttpRequestHeaders headers1;
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers1);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers1);
+
+  net::HttpRequestHeaders headers2;
+  request = CreateRequestByType(content::RESOURCE_TYPE_IMAGE, false /* https */,
+                                lofi_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers2);
+  VerifyAcceptTransformHeader(false /* lite-page */, true /* empty-image */,
+                              headers2);
+
+  net::HttpRequestHeaders headers3;
+  request = CreateRequestByType(content::RESOURCE_TYPE_FAVICON,
+                                false /* https */, lofi_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers3);
+  VerifyAcceptTransformHeader(false /* lite-page */, true /* empty-image */,
+                              headers3);
+
+  net::HttpRequestHeaders headers4;
+  request = CreateRequestByType(content::RESOURCE_TYPE_SCRIPT,
+                                false /* https */, lofi_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers4);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers4);
+
+  net::HttpRequestHeaders headers5;
+  request = CreateRequestByType(content::RESOURCE_TYPE_STYLESHEET,
+                                false /* https */, lofi_enabled);
+  lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false, &headers5);
+  VerifyAcceptTransformHeader(false /* lite-page */, false /* empty-image */,
+                              headers5);
+}
+
 TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
 
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     content::ResourceType resource_type;
   } tests[] = {{false, content::RESOURCE_TYPE_MAIN_FRAME},
@@ skipping 73 matching lines @@
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, false, headers);
     VerifyLitePageHeader(false, false, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrial) {
+  // Turn off proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled_Preview");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lite_page;
     bool is_main_frame;
   } tests[] = {
       {false, false}, {true, false}, {false, true}, {true, true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].is_main_frame, tests[i].is_using_lite_page
                                                   ? content::SERVER_LITE_PAGE_ON
                                                   : content::PREVIEWS_OFF);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, false, headers);
     VerifyLitePageHeader(tests[i].is_main_frame, !tests[i].is_using_lite_page,
                          headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lite_page, data->lofi_requested()) << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackDisabled) {
+  // Turn off proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled_Preview");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_using_lite_page;
     bool is_main_frame;
   } tests[] = {
       {false, false, false}, {false, false, true}, {true, false, true},
@@ skipping 19 matching lines @@
                          tests[i].is_main_frame && !tests[i].is_using_lite_page,
                          headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lofi || tests[i].is_using_lite_page,
               data->lofi_requested())
         << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, AutoLoFi) {
+  // Turn off proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
   const struct {
     bool auto_lofi_enabled_group;
     bool auto_lofi_control_group;
     bool network_prohibitively_slow;
     bool is_main_frame;
   } tests[] = {
       {false, false, false, false},
       {false, false, true, false},
       {true, false, false, false},
       {true, false, true, false},
@@ skipping 28 matching lines @@
         tests[i].is_main_frame, tests[i].network_prohibitively_slow);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
 
     VerifyLoFiHeader(expect_lofi_header, !tests[i].network_prohibitively_slow,
                      headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, SlowConnectionsFlag) {
+  // Turn off proxy-decides-transform feature for these unit tests.
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(
+      features::kDataReductionProxyDecidesTransform);
+
   const struct {
     bool slow_connections_flag_enabled;
     bool network_prohibitively_slow;
     bool auto_lofi_enabled_group;
     bool is_main_frame;
   } tests[] = {
       {false, false, false, false}, {false, true, false, false},
       {true, false, false, false},  {true, true, false, false},
       {true, true, false, true},    {false, false, true, false},
       {false, false, true, true},   {false, true, true, false},
@@ skipping 207 matching lines @@
                            content::CLIENT_LOFI_AUTO_RELOAD)));
 
   // IsClientLoFiAutoReloadRequest() should return false for any request without
   // the CLIENT_LOFI_AUTO_RELOAD bit set.
   EXPECT_FALSE(ContentLoFiDecider().IsClientLoFiAutoReloadRequest(
       *CreateRequestByType(content::RESOURCE_TYPE_IMAGE, false,
                            content::PREVIEWS_NO_TRANSFORM)));
 }
 
 }  // namespace data_reduction_proxy