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 265 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, MaybeSetAcceptTransformHeaderProxyDecides) {

[megjablon, 2017/05/30 18:38:53]

It looks like there's a lot of repeated code in this test. Is there any way we
can use a struct for it?

[dougarnett, 2017/05/30 22:15:48]

In my previous mondo CL, I had used the struct approach and Ben commented to not
take that approach (which I agree with). 
Perhaps this would be an interesting example to discuss trade-offs
with the struct approach.

[bengr, 2017/05/31 18:48:28]

I don't like the pattern of using an array of structs to handle various test
cases. Imo, each logical struct instance should be its own test. However I do
agree with Megan that there is a lot of code repetition. Can each block call the
same helper method? Something like VerifyStuff(...)? Also, unless these blocks
need to be in series, I'd break them into separate tests.

[dougarnett, 2017/05/31 23:05:21]

Ok, broke up into 4 difference tests with simplified verify method.

+  // 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;
+  content::PreviewsState lofi_enabled = content::SERVER_LOFI_ON;
+  content::PreviewsState both_previews_enabled =
+      lite_page_enabled | lofi_enabled;
+
+  // 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);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers);
+
+    request = CreateRequestByType(content::RESOURCE_TYPE_IMAGE,
+                                  true /* https */, both_previews_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers);
+  }
+
+  // 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);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, 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);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers);
+  }
+
+  // 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);
+    VerifyLitePageHeader(true /* lite-page */, false /*if-heavy */, headers1);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers1);
+
+    net::HttpRequestHeaders headers2;
+    request = CreateRequest(false /* is main */, lite_page_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers2);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers2);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers2);
+  }
+
+  // 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);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers1);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers1);
+
+    net::HttpRequestHeaders headers2;
+    request = CreateRequestByType(content::RESOURCE_TYPE_IMAGE,
+                                  false /* https */, lofi_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers2);
+    VerifyLitePageHeader(false /* lite-page */, false /*if-heavy */, headers2);
+    VerifyLoFiHeader(true /* empty-image */, false /*if-heavy */, headers2);
+
+    net::HttpRequestHeaders headers3;
+    request = CreateRequestByType(content::RESOURCE_TYPE_FAVICON,
+                                  false /* https */, lofi_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers3);
+    VerifyLoFiHeader(true /* empty-image */, false /*if-heavy */, headers3);
+
+    net::HttpRequestHeaders headers4;
+    request = CreateRequestByType(content::RESOURCE_TYPE_SCRIPT,
+                                  false /* https */, lofi_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers4);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers4);
+
+    net::HttpRequestHeaders headers5;
+    request = CreateRequestByType(content::RESOURCE_TYPE_STYLESHEET,
+                                  false /* https */, lofi_enabled);
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), false,
+                                                &headers5);
+    VerifyLoFiHeader(false /* empty-image */, false /*if-heavy */, headers5);
+  }
+}
+
 TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Add the Lite Page fallback field trial. Having this enabled when not in the
   // Enabled_Previews group should not affect how Lo-Fi works.
   base::FieldTrialList::CreateFieldTrial(
       params::GetLitePageFallbackFieldTrialName(), "Enabled");
 
   // Enable Lo-Fi.
@@ skipping 77 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, LitePageFieldTrialFallbackEnabled) {
+  // 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");
   base::FieldTrialList::CreateFieldTrial(
       params::GetLitePageFallbackFieldTrialName(), "Enabled");
 
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_using_lite_page;
@@ skipping 25 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, 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