Update CPAT protocol to send lite-page transform acceptance with ect

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 3bbfb38c263852f7bf5cda111ba4dc3ce43194b7..96fa67052f4a171d10d1fb0c6131ee43e8a0128d 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
@@ -88,7 +88,6 @@ class ContentLoFiDeciderTest : public testing::Test {
     data_reduction_proxy_network_delegate_->InitIODataAndUMA(
         test_context_->io_data(), test_context_->io_data()->bypass_stats());
 
-
     std::unique_ptr<data_reduction_proxy::ContentLoFiDecider>
         data_reduction_proxy_lofi_decider(
             new data_reduction_proxy::ContentLoFiDecider());
@@ -160,36 +159,22 @@ class ContentLoFiDeciderTest : public testing::Test {
   }
 
   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());
-      EXPECT_EQ(expected_lofi_used, empty_image_if_heavy == header_value);
-    } else {
-      EXPECT_EQ(expected_lofi_used, header_value == empty_image_directive());
-    }
+    EXPECT_EQ(expected_lofi_used, header_value == empty_image_directive());
   }
 
   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);
-    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());
-    }
+    EXPECT_EQ(expected_lofi_preview_used,
+              header_value == lite_page_directive());
   }
 
   static void VerifyVideoHeader(bool expected_compressed_video_used,
@@ -203,15 +188,14 @@ class ContentLoFiDeciderTest : public testing::Test {
         header_value.find(compressed_video_directive()) != std::string::npos);
   }
 
-  static void VerifyLitePageIgnoreBlacklistHeader(
-      bool expected_blacklist_directive_added,
+  static void VerifyForceLitePageHeader(
+      bool expected_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_blacklist_directive_added,
-              header_value.find(
-                  chrome_proxy_lite_page_ignore_blacklist_directive()) !=
+    EXPECT_EQ(expected_directive_added,
+              header_value.find(chrome_proxy_force_lite_page_directive()) !=
                   std::string::npos);
   }
 
@@ -220,15 +204,17 @@ class ContentLoFiDeciderTest : public testing::Test {
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
   std::unique_ptr<DataReductionProxyTestContext> test_context_;
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider>
+      data_reduction_proxy_lofi_decider_;
+
   std::unique_ptr<DataReductionProxyNetworkDelegate>
       data_reduction_proxy_network_delegate_;
 };
 
-TEST_F(ContentLoFiDeciderTest, LoFiFlags) {
-  // Enable Lo-Fi.
+TEST_F(ContentLoFiDeciderTest, MaybeSetAcceptTransformHeader) {
   const struct {
-    bool is_using_lofi;
-    bool is_using_lite_page;
+    bool is_server_lofi_on;
+    bool is_server_lite_page_on;
     bool is_main_frame;
   } tests[] = {
       {false, false, false}, {false, false, true}, {true, false, true},
@@ -236,96 +222,34 @@ TEST_F(ContentLoFiDeciderTest, LoFiFlags) {
       {true, true, true},    {true, true, false},
   };
 
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+
   for (size_t i = 0; i < arraysize(tests); ++i) {
     content::PreviewsState previews_state = content::PREVIEWS_UNSPECIFIED;
-    if (tests[i].is_using_lofi)
+    if (tests[i].is_server_lofi_on)
       previews_state |= content::SERVER_LOFI_ON;
-    if (tests[i].is_using_lite_page)
+    if (tests[i].is_server_lite_page_on)
       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);
-    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_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,
-                         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());
+    lofi_decider->MaybeSetAcceptTransformHeader(*request.get(), &headers);
 
-    // 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, 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(
-        switches::kDataReductionProxyLoFi,
-        switches::kDataReductionProxyLoFiValueCellularOnly);
-    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);
-    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_lite_page, !tests[i].is_using_lofi,
-                     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());
+    bool expect_lite_page =
+        tests[i].is_server_lite_page_on && tests[i].is_main_frame;
+    VerifyLitePageHeader(expect_lite_page, headers);
+
+    bool expect_lofi = tests[i].is_server_lofi_on && !tests[i].is_main_frame;
+    VerifyLoFiHeader(expect_lofi, headers);
   }
 }
 
-TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) {
+TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrialAndResourceTypes) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
@@ -391,253 +315,14 @@ TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) {
           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);
+    VerifyLoFiHeader(tests[i].is_using_lofi && is_lofi_resource_type, headers);
+    VerifyLitePageHeader(false, headers);
+    VerifyForceLitePageHeader(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 ? 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_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);
-    VerifyLitePageIgnoreBlacklistHeader(false, headers);
-    DataReductionProxyData* data = DataReductionProxyData::GetData(*request);
-    EXPECT_EQ(tests[i].is_using_lite_page, data->lofi_requested()) << i;
-  }
-}
-
-TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackEnabled) {
-  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;
-    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, LitePageFieldTrialFallbackDisabled) {
-  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(false, false, 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},
-      {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].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, !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[] = {
-      {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},
-      {true, false, true, false},   {true, true, true, false},
-  };
-
-  for (size_t i = 0; i < arraysize(tests); ++i) {
-    test_context_->config()->ResetLoFiStatusForTest();
-    // For the purpose of this test, Lo-Fi header is expected only if LoFi Slow
-    // Connection Flag is enabled or session is part of Lo-Fi enabled field
-    // trial. For both cases, an additional condition is that network must be
-    // prohibitively slow.
-    const bool expect_lofi_header = ((tests[i].slow_connections_flag_enabled &&
-                                      tests[i].network_prohibitively_slow) ||
-                                     (!tests[i].slow_connections_flag_enabled &&
-                                      tests[i].auto_lofi_enabled_group &&
-                                      tests[i].network_prohibitively_slow)) &&
-                                    !tests[i].is_main_frame;
-
-    std::string expected_header;
-
-    if (tests[i].slow_connections_flag_enabled) {
-      base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-          switches::kDataReductionProxyLoFi,
-          switches::kDataReductionProxyLoFiValueSlowConnectionsOnly);
-    }
-
-    base::FieldTrialList field_trial_list(nullptr);
-    if (tests[i].auto_lofi_enabled_group) {
-      base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
-                                             "Enabled");
-    }
-
-    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, false, headers);
-  }
-}
-
 TEST_F(ContentLoFiDeciderTest, ProxyIsNotDataReductionProxy) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
@@ -665,7 +350,6 @@ TEST_F(ContentLoFiDeciderTest, VideoDirectiveNotOverridden) {
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Verify the directive gets added even when LoFi is triggered.
-  test_context_->config()->SetNetworkProhibitivelySlow(true);
   std::unique_ptr<net::URLRequest> request =
       CreateRequestByType(content::RESOURCE_TYPE_MEDIA, false, true);
   net::HttpRequestHeaders headers;
@@ -677,7 +361,6 @@ TEST_F(ContentLoFiDeciderTest, VideoDirectiveNotAdded) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
-  test_context_->config()->SetNetworkProhibitivelySlow(true);
   std::unique_ptr<net::URLRequest> request =
       CreateRequestByType(content::RESOURCE_TYPE_MEDIA, false, true);
   net::HttpRequestHeaders headers;
@@ -691,7 +374,6 @@ TEST_F(ContentLoFiDeciderTest, VideoDirectiveDoesNotOverride) {
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Verify the directive gets added even when LoFi is triggered.
-  test_context_->config()->SetNetworkProhibitivelySlow(true);
   std::unique_ptr<net::URLRequest> request =
       CreateRequestByType(content::RESOURCE_TYPE_MEDIA, false, true);
   net::HttpRequestHeaders headers;
@@ -749,17 +431,17 @@ TEST_F(ContentLoFiDeciderTest, RemoveAcceptTransformHeader) {
   EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header()));
 }
 
-TEST_F(ContentLoFiDeciderTest, MaybeIgnoreBlacklist) {
+TEST_F(ContentLoFiDeciderTest, MaybeForceLitePage) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->InitFromArgv(command_line->argv());
   std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
       new data_reduction_proxy::ContentLoFiDecider());
   net::HttpRequestHeaders headers;
-  lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
   EXPECT_FALSE(headers.HasHeader(chrome_proxy_header()));
 
   headers.SetHeader(chrome_proxy_header(), "Foo");
-  lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
   std::string header_value;
   headers.GetHeader(chrome_proxy_header(), &header_value);
   EXPECT_EQ("Foo", header_value);
@@ -767,20 +449,47 @@ TEST_F(ContentLoFiDeciderTest, MaybeIgnoreBlacklist) {
   headers.RemoveHeader(chrome_proxy_header());
   command_line->AppendSwitch(switches::kEnableDataReductionProxyLitePage);
   headers.SetHeader(chrome_proxy_accept_transform_header(), "empty-image");
-  lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
+  EXPECT_FALSE(headers.HasHeader(chrome_proxy_header()));
+
+  headers.SetHeader(chrome_proxy_accept_transform_header(), "lite-page");
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
+  EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
+  headers.GetHeader(chrome_proxy_header(), &header_value);
+  EXPECT_EQ("exp=force_lite_page", header_value);
+
+  headers.SetHeader(chrome_proxy_header(), "Foo");
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
+  EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
+  headers.GetHeader(chrome_proxy_header(), &header_value);
+  EXPECT_EQ("Foo, exp=force_lite_page", header_value);
+}
+
+TEST_F(ContentLoFiDeciderTest, MaybeForceLitePageForCellularOnlyFlag) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  command_line->InitFromArgv(command_line->argv());
+  command_line->AppendSwitchASCII(
+      switches::kDataReductionProxyLoFi,
+      switches::kDataReductionProxyLoFiValueCellularOnly);
+  std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider(
+      new data_reduction_proxy::ContentLoFiDecider());
+  net::HttpRequestHeaders headers;
+  headers.SetHeader(chrome_proxy_accept_transform_header(), "empty-image");
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
   EXPECT_FALSE(headers.HasHeader(chrome_proxy_header()));
 
   headers.SetHeader(chrome_proxy_accept_transform_header(), "lite-page");
-  lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
   EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
+  std::string header_value;
   headers.GetHeader(chrome_proxy_header(), &header_value);
-  EXPECT_EQ("exp=ignore_preview_blacklist", header_value);
+  EXPECT_EQ("exp=force_lite_page", header_value);
 
   headers.SetHeader(chrome_proxy_header(), "Foo");
-  lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers);
+  lofi_decider->MaybeSetForceLitePageDirective(&headers);
   EXPECT_TRUE(headers.HasHeader(chrome_proxy_header()));
   headers.GetHeader(chrome_proxy_header(), &header_value);
-  EXPECT_EQ("Foo, exp=ignore_preview_blacklist", header_value);
+  EXPECT_EQ("Foo, exp=force_lite_page", header_value);
 }
 
 TEST_F(ContentLoFiDeciderTest, NoTransformDoesNotAddHeader) {
@@ -788,7 +497,7 @@ TEST_F(ContentLoFiDeciderTest, NoTransformDoesNotAddHeader) {
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   std::unique_ptr<net::URLRequest> request =
-      CreateRequest(false, content::PREVIEWS_NO_TRANSFORM);
+      CreateRequest(false, content::PREVIEWS_OFF);
   net::HttpRequestHeaders headers;
   NotifyBeforeSendHeaders(&headers, request.get(), true);
   EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header()));