Added support for heavy page previews transformations

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 "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_test_utils.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"
@@ skipping 133 matching lines @@
                                    const net::HttpRequestHeaders& headers) {
     if (expected_lite_page_used)
       EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header()));
     std::string header_value;
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
     EXPECT_EQ(expected_lite_page_used,
               header_value.find(lite_page_directive()) != std::string::npos);
   }
 
   static void VerifyLoFiHeader(bool expected_lofi_used,
+                               bool expected_if_heavy,
                                const net::HttpRequestHeaders& headers) {
     if (expected_lofi_used)
       EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header()));
     std::string header_value;
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
-    EXPECT_EQ(expected_lofi_used,
-              header_value.find(empty_image_directive()) != std::string::npos);
+    if (expected_if_heavy) {
+      std::string empty_image_if_heavy = base::StringPrintf(
+          "%s;%s", empty_image_directive(), if_heavy_qualifier());
+      EXPECT_EQ(expected_lofi_used, empty_image_if_heavy == header_value);
+    } else {
+      EXPECT_EQ(expected_lofi_used, header_value == empty_image_directive());
+    }
   }
 
-  static void VerifyLoFiPreviewHeader(bool expected_lofi_preview_used,
-                                      const net::HttpRequestHeaders& headers) {
+  static void VerifyLitePageHeader(bool expected_lofi_preview_used,
+                                   bool expected_if_heavy,
+                                   const net::HttpRequestHeaders& headers) {
     if (expected_lofi_preview_used)
       EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header()));
     std::string header_value;
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
-    EXPECT_EQ(expected_lofi_preview_used,
-              header_value.find(lite_page_directive()) != std::string::npos);
+    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());
+    }
   }
 
   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);
   }
 
   static void VerifyLitePageIgnoreBlacklistHeader(
-      bool expected_lite_page_used,
+      bool expected_blacklist_directive_added,
       const net::HttpRequestHeaders& headers) {
     EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
     std::string header_value;
     headers.GetHeader(chrome_proxy_header(), &header_value);
-    EXPECT_EQ(expected_lite_page_used,
+    EXPECT_EQ(expected_blacklist_directive_added,
               header_value.find(
                   chrome_proxy_lite_page_ignore_blacklist_directive()) !=
                   std::string::npos);
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   net::MockClientSocketFactory mock_socket_factory_;
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
@@ skipping 19 matching lines @@
         CreateRequest(tests[i].is_main_frame, tests[i].is_using_lofi);
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->InitFromArgv(command_line->argv());
     if (tests[i].is_using_lite_page) {
       command_line->AppendSwitch(switches::kEnableDataReductionProxyLitePage);
     }
 
     // No flags or field trials. The Lo-Fi header should not be added.
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(false, headers);
-    VerifyLitePageHeader(false, headers);
+    VerifyLoFiHeader(false, false, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
 
     // The Lo-Fi flag is "always-on", Lo-Fi is being used, and it's a main frame
     // request. Lo-Fi or lite page header should be added.
     command_line->AppendSwitchASCII(
         switches::kDataReductionProxyLoFi,
         switches::kDataReductionProxyLoFiValueAlwaysOn);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_lite_page &&
-                         !tests[i].is_main_frame,
-                     headers);
-    VerifyLitePageHeader(tests[i].is_using_lofi &&
-                             tests[i].is_using_lite_page &&
-                             tests[i].is_main_frame,
-                         headers);
-    VerifyLitePageIgnoreBlacklistHeader(tests[i].is_using_lofi &&
-                                            tests[i].is_using_lite_page &&
-                                            tests[i].is_main_frame,
-                                        headers);
+    VerifyLoFiHeader(!tests[i].is_using_lite_page && !tests[i].is_main_frame,
+                     !tests[i].is_using_lofi, headers);
+    VerifyLitePageHeader(tests[i].is_using_lite_page && tests[i].is_main_frame,
+                         !tests[i].is_using_lofi, headers);
+    VerifyLitePageIgnoreBlacklistHeader(
+        tests[i].is_using_lite_page && tests[i].is_main_frame, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     // |lofi_requested| should be set to false when Lo-Fi is enabled using
     // flags.
     EXPECT_FALSE(data->lofi_requested());
 
     // The Lo-Fi flag is "always-on" and Lo-Fi is being used. Lo-Fi header
     // should be added.
     AllocateRequestInfoForTesting(request.get(),
                                   content::RESOURCE_TYPE_SUB_FRAME,
                                   tests[i].is_using_lofi);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_lite_page,
+    VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi,
                      headers);
-    VerifyLitePageHeader(false, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
 
     // The Lo-Fi flag is "cellular-only" and Lo-Fi is being used. Lo-Fi header
     // should be added.
     command_line->AppendSwitchASCII(
         switches::kDataReductionProxyLoFi,
         switches::kDataReductionProxyLoFiValueCellularOnly);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_lite_page,
+    VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi,
                      headers);
-    VerifyLitePageHeader(false, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(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());
 
     // The Lo-Fi flag is "slow-connections-only" and Lo-Fi is being used. Lo-Fi
     // header should be added.
     command_line->AppendSwitchASCII(
         switches::kDataReductionProxyLoFi,
         switches::kDataReductionProxyLoFiValueSlowConnectionsOnly);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(tests[i].is_using_lofi && !tests[i].is_using_lite_page,
+    VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi,
                      headers);
-    VerifyLitePageHeader(false, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(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, LoFiEnabledFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
@@ skipping 47 matching lines @@
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     bool is_lofi_resource_type =
         !(tests[i].resource_type == content::RESOURCE_TYPE_MAIN_FRAME ||
           tests[i].resource_type == content::RESOURCE_TYPE_STYLESHEET ||
           tests[i].resource_type == content::RESOURCE_TYPE_SCRIPT ||
           tests[i].resource_type == content::RESOURCE_TYPE_FONT_RESOURCE ||
           tests[i].resource_type == content::RESOURCE_TYPE_MEDIA ||
           tests[i].resource_type == content::RESOURCE_TYPE_CSP_REPORT);
 
-    VerifyLoFiHeader(tests[i].is_using_lofi && is_lofi_resource_type, headers);
-    VerifyLoFiPreviewHeader(false, headers);
+    VerifyLoFiHeader(is_lofi_resource_type, !tests[i].is_using_lofi, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Control");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_main_frame;
   } tests[] = {{false, false}, {false, true}, {true, false}, {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_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(false, headers);
-    VerifyLitePageHeader(false, headers);
+    VerifyLoFiHeader(false, false, headers);
+    VerifyLitePageHeader(false, false, headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled_Preview");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     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_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
-    VerifyLoFiHeader(false, headers);
-    VerifyLitePageHeader(tests[i].is_using_lofi && tests[i].is_main_frame,
+    VerifyLoFiHeader(false, false, headers);
+    VerifyLitePageHeader(tests[i].is_main_frame, !tests[i].is_using_lofi,
                          headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
     EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i;
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, AutoLoFi) {
   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},
       {true, false, true, true},
       {false, true, false, false},
       {false, true, true, false},
       // Repeat this test data to simulate user moving out of Lo-Fi control
       // experiment.
       {false, true, false, false},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     test_context_->config()->ResetLoFiStatusForTest();
     const bool expect_lofi_header = tests[i].auto_lofi_enabled_group &&
-                                    tests[i].network_prohibitively_slow &&
                                     !tests[i].is_main_frame;
 
     base::FieldTrialList field_trial_list(nullptr);
     if (tests[i].auto_lofi_enabled_group) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
 
     if (tests[i].auto_lofi_control_group) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Control");
     }
 
     test_context_->config()->SetNetworkProhibitivelySlow(
         tests[i].network_prohibitively_slow);
 
     std::unique_ptr<net::URLRequest> request = CreateRequest(
         tests[i].is_main_frame, tests[i].network_prohibitively_slow);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
 
-    VerifyLoFiHeader(expect_lofi_header, headers);
+    VerifyLoFiHeader(expect_lofi_header, !tests[i].network_prohibitively_slow,
+                     headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, SlowConnectionsFlag) {
   const struct {
     bool slow_connections_flag_enabled;
     bool network_prohibitively_slow;
     bool auto_lofi_enabled_group;
     bool is_main_frame;
   } tests[] = {
@@ skipping 32 matching lines @@
     }
 
     test_context_->config()->SetNetworkProhibitivelySlow(
         tests[i].network_prohibitively_slow);
 
     std::unique_ptr<net::URLRequest> request = CreateRequest(
         tests[i].is_main_frame, tests[i].network_prohibitively_slow);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
 
-    VerifyLoFiHeader(expect_lofi_header, headers);
+    VerifyLoFiHeader(expect_lofi_header, false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, ProxyIsNotDataReductionProxy) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
@@ skipping 129 matching lines @@
   EXPECT_EQ("exp=ignore_preview_blacklist", header_value);
 
   headers.SetHeader(chrome_proxy_header(), "Foo");
   lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
   EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
   headers.GetHeader(chrome_proxy_header(), &header_value);
   EXPECT_EQ("Foo, exp=ignore_preview_blacklist", header_value);
 }
 
 }  // namespace data_reduction_roxy