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

components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate_unittest.cc

 // Copyright 2014 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/core/browser/data_reduction_proxy_network_delegate.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 83 matching lines @@
 const Client kClient = Client::UNKNOWN;
 #endif
 
 class TestLoFiDecider : public LoFiDecider {
  public:
   TestLoFiDecider()
       : should_request_lofi_resource_(false),
         ignore_is_using_data_reduction_proxy_check_(false) {}
   ~TestLoFiDecider() override {}
 
-  bool IsUsingLoFiMode(const net::URLRequest& request) const override {
+  bool IsUsingLoFi(const net::URLRequest& request) const override {
     return should_request_lofi_resource_;
   }
 
-  void SetIsUsingLoFiMode(bool should_request_lofi_resource) {
+  void SetIsUsingLoFi(bool should_request_lofi_resource) {
     should_request_lofi_resource_ = should_request_lofi_resource;
   }
 
   void MaybeSetAcceptTransformHeader(
       const net::URLRequest& request,
       bool is_previews_disabled,
       net::HttpRequestHeaders* headers) const override {
     if (should_request_lofi_resource_) {
       headers->SetHeader(chrome_proxy_accept_transform_header(),
                          empty_image_directive());
@@ skipping 397 matching lines @@
 
     {
       // Main frame loaded. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
 
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME_DEPRECATED);
-      lofi_decider()->SetIsUsingLoFiMode(
-          config()->ShouldEnableLoFiMode(*fake_request.get()));
+      lofi_decider()->SetIsUsingLoFi(
+          config()->ShouldEnableLoFi(*fake_request.get()));
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
 
       VerifyHeaders(tests[i].is_data_reduction_proxy, true, headers);
       VerifyDataReductionProxyData(
           *fake_request, tests[i].is_data_reduction_proxy,
-          config()->ShouldEnableLoFiMode(*fake_request.get()));
+          config()->ShouldEnableLoFi(*fake_request.get()));
     }
 
     {
       // Lo-Fi is already off. Lo-Fi should not be used.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
-      lofi_decider()->SetIsUsingLoFiMode(false);
+      lofi_decider()->SetIsUsingLoFi(false);
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
       VerifyHeaders(tests[i].is_data_reduction_proxy, false, headers);
       VerifyDataReductionProxyData(*fake_request,
                                    tests[i].is_data_reduction_proxy, false);
     }
 
     {
       // Lo-Fi is already on. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
 
-      lofi_decider()->SetIsUsingLoFiMode(true);
+      lofi_decider()->SetIsUsingLoFi(true);
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
       VerifyHeaders(tests[i].is_data_reduction_proxy, true, headers);
       VerifyDataReductionProxyData(*fake_request,
                                    tests[i].is_data_reduction_proxy, true);
     }
 
     {
       // Main frame request with Lo-Fi off. Lo-Fi should not be used.
       // State of Lo-Fi should persist until next page load.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME_DEPRECATED);
-      lofi_decider()->SetIsUsingLoFiMode(false);
+      lofi_decider()->SetIsUsingLoFi(false);
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
       VerifyHeaders(tests[i].is_data_reduction_proxy, false, headers);
       VerifyDataReductionProxyData(*fake_request,
                                    tests[i].is_data_reduction_proxy, false);
     }
 
     {
       // Lo-Fi is off. Lo-Fi is still not used.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
-      lofi_decider()->SetIsUsingLoFiMode(false);
+      lofi_decider()->SetIsUsingLoFi(false);
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
       VerifyHeaders(tests[i].is_data_reduction_proxy, false, headers);
       VerifyDataReductionProxyData(*fake_request,
                                    tests[i].is_data_reduction_proxy, false);
     }
 
     {
       // Main frame request. Lo-Fi should be used.
       net::HttpRequestHeaders headers;
       net::ProxyRetryInfoMap proxy_retry_info;
       net::TestDelegate delegate;
       std::unique_ptr<net::URLRequest> fake_request =
           context()->CreateRequest(GURL(kTestURL), net::IDLE, &delegate);
       fake_request->SetLoadFlags(net::LOAD_MAIN_FRAME_DEPRECATED);
-      lofi_decider()->SetIsUsingLoFiMode(
-          config()->ShouldEnableLoFiMode(*fake_request.get()));
+      lofi_decider()->SetIsUsingLoFi(
+          config()->ShouldEnableLoFi(*fake_request.get()));
       NotifyNetworkDelegate(fake_request.get(), data_reduction_proxy_info,
                             proxy_retry_info, &headers);
       VerifyDataReductionProxyData(
           *fake_request, tests[i].is_data_reduction_proxy,
-          config()->ShouldEnableLoFiMode(*fake_request.get()));
+          config()->ShouldEnableLoFi(*fake_request.get()));
     }
   }
 }
 
 TEST_F(DataReductionProxyNetworkDelegateTest, RequestDataConfigurations) {
   Init(false, false);
   const struct {
     bool lofi_on;
     bool used_data_reduction_proxy;
     bool main_frame;
@@ skipping 32 matching lines @@
 
     net::TestNetworkQualityEstimator test_network_quality_estimator;
     test_network_quality_estimator.set_effective_connection_type(
         net::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
     context()->set_network_quality_estimator(&test_network_quality_estimator);
 
     std::unique_ptr<net::URLRequest> request = context()->CreateRequest(
         GURL(kTestURL), net::RequestPriority::IDLE, nullptr);
     request->SetLoadFlags(test.main_frame ? net::LOAD_MAIN_FRAME_DEPRECATED
                                           : 0);
-    lofi_decider()->SetIsUsingLoFiMode(test.lofi_on);
+    lofi_decider()->SetIsUsingLoFi(test.lofi_on);
     io_data()->request_options()->SetSecureSession("fake-session");
     network_delegate()->NotifyBeforeSendHeaders(
         request.get(), data_reduction_proxy_info, proxy_retry_info, &headers);
     DataReductionProxyData* data =
         DataReductionProxyData::GetData(*request.get());
     if (!test.used_data_reduction_proxy) {
       EXPECT_FALSE(data);
     } else {
       EXPECT_TRUE(data);
       EXPECT_EQ(test.main_frame ? net::EFFECTIVE_CONNECTION_TYPE_OFFLINE
@@ skipping 67 matching lines @@
   net::ProxyRetryInfoMap proxy_retry_info;
 
   net::TestNetworkQualityEstimator test_network_quality_estimator;
   test_network_quality_estimator.set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_OFFLINE);
   context()->set_network_quality_estimator(&test_network_quality_estimator);
 
   std::unique_ptr<net::URLRequest> request = context()->CreateRequest(
       GURL(kTestURL), net::RequestPriority::IDLE, nullptr);
   request->SetLoadFlags(net::LOAD_MAIN_FRAME_DEPRECATED);
-  lofi_decider()->SetIsUsingLoFiMode(true);
+  lofi_decider()->SetIsUsingLoFi(true);
   io_data()->request_options()->SetSecureSession("fake-session");
   network_delegate()->NotifyBeforeSendHeaders(
       request.get(), data_reduction_proxy_info, proxy_retry_info, &headers);
   DataReductionProxyData* data =
       DataReductionProxyData::GetData(*request.get());
 
   EXPECT_TRUE(data);
   EXPECT_EQ(net::EFFECTIVE_CONNECTION_TYPE_OFFLINE,
             data->effective_connection_type());
   EXPECT_TRUE(data->used_data_reduction_proxy());
@@ skipping 125 matching lines @@
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
 
     if (tests[i].lofi_enabled_through_switch) {
       base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
           switches::kDataReductionProxyLoFi,
           switches::kDataReductionProxyLoFiValueAlwaysOn);
     }
 
-    lofi_decider()->SetIsUsingLoFiMode(
-        config()->ShouldEnableLoFiMode(*fake_request.get()));
+    lofi_decider()->SetIsUsingLoFi(
+        config()->ShouldEnableLoFi(*fake_request.get()));
 
     fake_request = (FetchURLRequest(GURL(kTestURL), nullptr, response_headers,
                                     kResponseContentLength));
     fake_request->SetLoadFlags(fake_request->load_flags() |
                                net::LOAD_MAIN_FRAME_DEPRECATED);
 
     // Histograms are accumulative, so get the sum of all the tests so far.
     int expected_count = 0;
     for (size_t j = 0; j <= i; ++j)
       expected_count += tests[j].expected_count;
@@ skipping 158 matching lines @@
       "Vary: accept-encoding\r\n";
   response_headers += "\r\n";
 
   FetchURLRequestAndVerifyBrotli(nullptr, response_headers, false, true);
   FetchURLRequestAndVerifyBrotli(nullptr, response_headers, true, true);
 }
 
 }  // namespace
 
 }  // namespace data_reduction_proxy