Create a Lite Page bit for previews and fallback to Lo-Fi

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>
@@ skipping 89 matching lines @@
                                      content::PreviewsState previews_state) {
     content::ResourceRequestInfo::AllocateForTesting(
         request, resource_type, NULL, -1, -1, -1,
         resource_type == content::RESOURCE_TYPE_MAIN_FRAME,
         false,  // parent_is_main_frame
         false,  // allow_download
         false,  // is_async
         previews_state);
   }
 
-  std::unique_ptr<net::URLRequest> CreateRequest(bool is_main_frame,
-                                                 bool is_using_lofi) {
+  std::unique_ptr<net::URLRequest> CreateRequest(
+      bool is_main_frame,
+      content::PreviewsState previews_state) {
     std::unique_ptr<net::URLRequest> request = context_.CreateRequest(
         GURL("http://www.google.com/"), net::IDLE, &delegate_);
     AllocateRequestInfoForTesting(
         request.get(), (is_main_frame ? content::RESOURCE_TYPE_MAIN_FRAME
                                       : content::RESOURCE_TYPE_SUB_FRAME),
-        is_using_lofi ? content::SERVER_LOFI_ON : content::PREVIEWS_OFF);
+        previews_state);
     return request;
   }
 
   std::unique_ptr<net::URLRequest> CreateRequestByType(
       content::ResourceType resource_type,
       bool scheme_is_https,
-      bool is_using_lofi) {
+      content::PreviewsState previews_state) {
     std::unique_ptr<net::URLRequest> request =
         context_.CreateRequest(GURL(scheme_is_https ? "https://www.google.com/"
                                                     : "http://www.google.com/"),
                                net::IDLE, &delegate_);
-    AllocateRequestInfoForTesting(
-        request.get(), resource_type,
-        is_using_lofi ? content::SERVER_LOFI_ON : content::PREVIEWS_OFF);
+    AllocateRequestInfoForTesting(request.get(), resource_type, previews_state);
     return request;
   }
 
-  std::unique_ptr<net::URLRequest> CreateNoTransformRequest(
-      bool is_main_frame) {
-    std::unique_ptr<net::URLRequest> request = context_.CreateRequest(
-        GURL("http://www.google.com/"), net::IDLE, &delegate_);
-    AllocateRequestInfoForTesting(
-        request.get(), (is_main_frame ? content::RESOURCE_TYPE_MAIN_FRAME
-                                      : content::RESOURCE_TYPE_SUB_FRAME),
-        content::PREVIEWS_NO_TRANSFORM);
-    return request;
-  }
-
   void DelegateStageDone(int result) {}
 
   void NotifyBeforeSendHeaders(net::HttpRequestHeaders* headers,
                                net::URLRequest* request,
                                bool use_data_reduction_proxy) {
     net::ProxyInfo data_reduction_proxy_info;
     net::ProxyRetryInfoMap proxy_retry_info;
 
     if (use_data_reduction_proxy) {
       std::string data_reduction_proxy;
       base::TrimString(test_context_->config()->test_params()->DefaultOrigin(),
                        "/", &data_reduction_proxy);
       data_reduction_proxy_info.UseNamedProxy(data_reduction_proxy);
     } else {
       data_reduction_proxy_info.UseNamedProxy("proxy.com");
     }
 
     data_reduction_proxy_network_delegate_->NotifyBeforeStartTransaction(
         request, base::Bind(&ContentLoFiDeciderTest::DelegateStageDone,
                             base::Unretained(this)),
         headers);
     data_reduction_proxy_network_delegate_->NotifyBeforeSendHeaders(
         request, data_reduction_proxy_info, proxy_retry_info, headers);
   }
 
-  static void VerifyLitePageHeader(bool expected_lite_page_used,
-                                   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);
     if (expected_if_heavy) {
       std::string empty_image_if_heavy = base::StringPrintf(
           "%s;%s", empty_image_directive(), if_heavy_qualifier());
@@ skipping 58 matching lines @@
     bool is_using_lofi;
     bool is_using_lite_page;
     bool is_main_frame;
   } tests[] = {
       {false, false, false}, {false, false, true}, {true, false, true},
       {true, false, false},  {false, true, false}, {false, true, true},
       {true, true, true},    {true, true, false},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
+    content::PreviewsState previews_state = content::PREVIEWS_UNSPECIFIED;
+    if (tests[i].is_using_lofi)
+      previews_state |= content::SERVER_LOFI_ON;
+    if (tests[i].is_using_lite_page)
+      previews_state |= content::SERVER_LITE_PAGE_ON;
+    if (previews_state == content::PREVIEWS_UNSPECIFIED)
+      previews_state = content::PREVIEWS_OFF;
+
     std::unique_ptr<net::URLRequest> request =
-        CreateRequest(tests[i].is_main_frame, tests[i].is_using_lofi);
+        CreateRequest(tests[i].is_main_frame, previews_state);
     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, 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_lite_page && !tests[i].is_main_frame,
-                     !tests[i].is_using_lofi, headers);
+    VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page,
+                     !tests[i].is_main_frame && !tests[i].is_using_lofi &&
+                         !tests[i].is_using_lite_page,
+                     headers);
     VerifyLitePageHeader(tests[i].is_using_lite_page && tests[i].is_main_frame,
-                         !tests[i].is_using_lofi, headers);
+                         false, 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 ? content::SERVER_LOFI_ON
-                               : content::PREVIEWS_OFF);
+        request.get(), content::RESOURCE_TYPE_SUB_FRAME, previews_state);
     headers.Clear();
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi,
                      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(
@@ skipping 68 matching lines @@
                {true, content::RESOURCE_TYPE_SHARED_WORKER},
                {true, content::RESOURCE_TYPE_PREFETCH},
                {true, content::RESOURCE_TYPE_FAVICON},
                {true, content::RESOURCE_TYPE_XHR},
                {true, content::RESOURCE_TYPE_PING},
                {true, content::RESOURCE_TYPE_SERVICE_WORKER},
                {true, content::RESOURCE_TYPE_CSP_REPORT},
                {true, content::RESOURCE_TYPE_PLUGIN_RESOURCE}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    std::unique_ptr<net::URLRequest> request = CreateRequestByType(
-        tests[i].resource_type, false, tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequestByType(tests[i].resource_type, false,
+                            tests[i].is_using_lofi ? content::SERVER_LOFI_ON
+                                                   : content::PREVIEWS_OFF);
     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(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);
+    std::unique_ptr<net::URLRequest> request = CreateRequest(
+        tests[i].is_main_frame, tests[i].is_using_lofi ? content::SERVER_LOFI_ON
+                                                       : content::PREVIEWS_OFF);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), true);
     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_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_lofi);
+        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_lofi,
+    VerifyLitePageHeader(tests[i].is_main_frame, !tests[i].is_using_lite_page,
                          headers);
     VerifyLitePageIgnoreBlacklistHeader(false, headers);
     DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
-    EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i;
+    EXPECT_EQ(tests[i].is_using_lite_page, data->lofi_requested()) << i;
   }
 }
 
+TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackToLoFi) {
+  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},
+      {true, false, false},  {false, true, false}, {false, true, true},
+      {true, true, true},    {true, true, false},
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    content::PreviewsState previews_state = content::PREVIEWS_UNSPECIFIED;
+    if (tests[i].is_using_lofi)
+      previews_state |= content::SERVER_LOFI_ON;
+    if (tests[i].is_using_lite_page)
+      previews_state |= content::SERVER_LITE_PAGE_ON;
+    if (previews_state == content::PREVIEWS_UNSPECIFIED)
+      previews_state = content::PREVIEWS_OFF;
+
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_main_frame, previews_state);
+    net::HttpRequestHeaders headers;
+    NotifyBeforeSendHeaders(&headers, request.get(), true);
+    VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page,
+                     !tests[i].is_main_frame && !tests[i].is_using_lofi &&
+                         !tests[i].is_using_lite_page,
+                     headers);
+    VerifyLitePageHeader(tests[i].is_main_frame,
+                         tests[i].is_main_frame && !tests[i].is_using_lite_page,
+                         headers);
+    VerifyLitePageIgnoreBlacklistHeader(false, 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) {
   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},
@@ skipping 87 matching lines @@
     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;
+    content::PreviewsState previews_state;
   } tests[] = {
-      {false}, {true},
+      {content::PREVIEWS_OFF}, {content::SERVER_LOFI_ON},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::unique_ptr<net::URLRequest> request =
-        CreateRequest(false, tests[i].is_using_lofi);
+        CreateRequest(false, tests[i].previews_state);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendHeaders(&headers, request.get(), false);
     std::string header_value;
     headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value);
     EXPECT_EQ(std::string::npos, header_value.find(empty_image_directive()));
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, VideoDirectiveNotOverridden) {
   base::FieldTrialList field_trial_list(nullptr);
@@ skipping 115 matching lines @@
   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);
 }
 
 TEST_F(ContentLoFiDeciderTest, NoTransformDoesNotAddHeader) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
-  std::unique_ptr<net::URLRequest> request = CreateNoTransformRequest(false);
+  std::unique_ptr<net::URLRequest> request =
+      CreateRequest(false, content::PREVIEWS_NO_TRANSFORM);
   net::HttpRequestHeaders headers;
   NotifyBeforeSendHeaders(&headers, request.get(), true);
   EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header()));
 }
 
 }  // namespace data_reduction_proxy