New CPAT support in ContentLoFiDecider guarded by feature flag.

components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc

Index: components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc
diff --git a/components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc b/components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc
index 1b8d9de53cbbeed13d99e642259b20ae3b19550b..bbf3c176e293736c3c541febb001f9e64e0e0f7b 100644
--- a/components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc
+++ b/components/data_reduction_proxy/content/browser/content_lofi_decider_unittest.cc
@@ -15,12 +15,14 @@
 #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"
@@ -192,6 +194,24 @@ class ContentLoFiDeciderTest : public testing::Test {
     }
   }
 

[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,
@@ -306,6 +326,138 @@ TEST_F(ContentLoFiDeciderTest, LoFiFlags) {
   }
 }
 
+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(),
@@ -399,6 +551,11 @@ TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) {
 }
 
 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");
@@ -426,6 +583,11 @@ TEST_F(ContentLoFiDeciderTest, LitePageFieldTrial) {
 }
 
 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");
@@ -465,6 +627,11 @@ TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackDisabled) {
 }
 
 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;
@@ -513,6 +680,11 @@ TEST_F(ContentLoFiDeciderTest, AutoLoFi) {
 }
 
 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;