Add support to previews/ for Server LoFi and LitePages

components/previews/core/previews_io_data_unittest.cc

 // Copyright 2016 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/previews/core/previews_io_data.h"
 
 #include <initializer_list>
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/previews/core/previews_black_list.h"
 #include "components/previews/core/previews_black_list_item.h"
+#include "components/previews/core/previews_experiments.h"
 #include "components/previews/core/previews_opt_out_store.h"
 #include "components/previews/core/previews_ui_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/base/load_flags.h"
 #include "net/nqe/effective_connection_type.h"
 #include "net/nqe/network_quality_estimator_test_util.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace previews {
 
 namespace {
 
-// TODO(sclittle): Tests should be testing the actual prod code that checks if
-// the appropriate field trial is enabled for the preview, instead of testing
-// this function here. Consider moving that code out of
-// chrome/browser/previews/previews_service.cc and into the previews/ component.
+// This method simulates the actual behavior of the passed in callback, which is
+// validated in other tests. For simplicity, offline, lite page, and server LoFi
+// use the offline previews check. Client LoFi uses a seperate check to verify
+// that types are treated differently.
 bool IsPreviewFieldTrialEnabled(PreviewsType type) {
   switch (type) {
     case PreviewsType::OFFLINE:
+    case PreviewsType::LITE_PAGE:
       return params::IsOfflinePreviewsEnabled();
-    case PreviewsType::CLIENT_LOFI:
+    case PreviewsType::LOFI:
       return params::IsClientLoFiEnabled();
     case PreviewsType::NONE:
     case PreviewsType::LAST:
       break;
   }
   NOTREACHED();
   return false;
 }
 
 class TestPreviewsIOData : public PreviewsIOData {
@@ skipping 204 matching lines @@
 
   base::HistogramTester histogram_tester;
   EXPECT_FALSE(
       io_data()->ShouldAllowPreview(*CreateRequest(), PreviewsType::OFFLINE));
   histogram_tester.ExpectUniqueSample(
       "Previews.EligibilityReason.Offline",
       static_cast<int>(PreviewsEligibilityReason::NETWORK_QUALITY_UNAVAILABLE),
       1);
 }
 
+TEST_F(PreviewsIODataTest, TestAllowLitePageWhenNetworkQualityFast) {
+  // LoFi and LitePage check NQE on their own.
+  InitializeUIService();
+  CreateFieldTrialWithParams("ClientSidePreviews", "Enabled",
+                             {{"show_offline_pages", "true"},
+                              {"max_allowed_effective_connection_type", "2G"}});
+
+  network_quality_estimator()->set_effective_connection_type(
+      net::EFFECTIVE_CONNECTION_TYPE_3G);
+
+  base::HistogramTester histogram_tester;
+  EXPECT_TRUE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LITE_PAGE,
+      net::EFFECTIVE_CONNECTION_TYPE_4G));
+  histogram_tester.ExpectUniqueSample(
+      "Previews.EligibilityReason.LitePage",
+      static_cast<int>(PreviewsEligibilityReason::ALLOWED), 1);
+}
+
 TEST_F(PreviewsIODataTest, TestDisallowOfflineWhenNetworkQualityFast) {
   InitializeUIService();
   CreateFieldTrialWithParams("ClientSidePreviews", "Enabled",
                              {{"show_offline_pages", "true"},
                               {"max_allowed_effective_connection_type", "2G"}});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_3G);
 
   base::HistogramTester histogram_tester;
@@ skipping 13 matching lines @@
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_2G);
 
   std::unique_ptr<net::URLRequest> request = CreateRequest();
   request->SetLoadFlags(net::LOAD_BYPASS_CACHE);
 
   base::HistogramTester histogram_tester;
   EXPECT_FALSE(io_data()->ShouldAllowPreview(*request, PreviewsType::OFFLINE));
   histogram_tester.ExpectUniqueSample(
       "Previews.EligibilityReason.Offline",
-      static_cast<int>(
-          PreviewsEligibilityReason::RELOAD_DISALLOWED_FOR_OFFLINE),
-      1);
+      static_cast<int>(PreviewsEligibilityReason::RELOAD_DISALLOWED), 1);
 }
 
 TEST_F(PreviewsIODataTest, TestAllowOffline) {
   InitializeUIService();
   CreateFieldTrialWithParams("ClientSidePreviews", "Enabled",
                              {{"show_offline_pages", "true"},
                               {"max_allowed_effective_connection_type", "2G"}});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_2G);
 
   base::HistogramTester histogram_tester;
   EXPECT_TRUE(
       io_data()->ShouldAllowPreview(*CreateRequest(), PreviewsType::OFFLINE));
   histogram_tester.ExpectUniqueSample(
       "Previews.EligibilityReason.Offline",
       static_cast<int>(PreviewsEligibilityReason::ALLOWED), 1);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiDisallowedByDefault) {
   InitializeUIService();
 
   base::HistogramTester histogram_tester;
-  EXPECT_FALSE(io_data()->ShouldAllowPreview(*CreateRequest(),
-                                             PreviewsType::CLIENT_LOFI));
-  histogram_tester.ExpectTotalCount("Previews.EligibilityReason.ClientLoFi", 0);
+  EXPECT_FALSE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
+  histogram_tester.ExpectTotalCount("Previews.EligibilityReason.LoFi", 0);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiDisallowedWhenFieldTrialDisabled) {
   InitializeUIService();
   CreateFieldTrialWithParams("PreviewsClientLoFi", "Disabled", {});
 
   base::HistogramTester histogram_tester;
-  EXPECT_FALSE(io_data()->ShouldAllowPreview(*CreateRequest(),
-                                             PreviewsType::CLIENT_LOFI));
-  histogram_tester.ExpectTotalCount("Previews.EligibilityReason.ClientLoFi", 0);
+  EXPECT_FALSE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
+  histogram_tester.ExpectTotalCount("Previews.EligibilityReason.LoFi", 0);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiDisallowedWhenNetworkQualityUnavailable) {
   InitializeUIService();
   CreateFieldTrialWithParams("PreviewsClientLoFi", "Enabled", {});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 
   base::HistogramTester histogram_tester;
-  EXPECT_FALSE(io_data()->ShouldAllowPreview(*CreateRequest(),
-                                             PreviewsType::CLIENT_LOFI));
+  EXPECT_FALSE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
   histogram_tester.ExpectUniqueSample(
-      "Previews.EligibilityReason.ClientLoFi",
+      "Previews.EligibilityReason.LoFi",
       static_cast<int>(PreviewsEligibilityReason::NETWORK_QUALITY_UNAVAILABLE),
       1);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiDisallowedWhenNetworkFast) {
   InitializeUIService();
   CreateFieldTrialWithParams("PreviewsClientLoFi", "Enabled",
                              {{"max_allowed_effective_connection_type", "2G"}});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_3G);
 
   base::HistogramTester histogram_tester;
-  EXPECT_FALSE(io_data()->ShouldAllowPreview(*CreateRequest(),
-                                             PreviewsType::CLIENT_LOFI));
+  EXPECT_FALSE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
   histogram_tester.ExpectUniqueSample(
-      "Previews.EligibilityReason.ClientLoFi",
+      "Previews.EligibilityReason.LoFi",
       static_cast<int>(PreviewsEligibilityReason::NETWORK_NOT_SLOW), 1);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiAllowed) {
   InitializeUIService();
   CreateFieldTrialWithParams("PreviewsClientLoFi", "Enabled",
                              {{"max_allowed_effective_connection_type", "2G"}});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_2G);
 
   base::HistogramTester histogram_tester;
-  EXPECT_TRUE(io_data()->ShouldAllowPreview(*CreateRequest(),
-                                            PreviewsType::CLIENT_LOFI));
+  EXPECT_TRUE(io_data()->ShouldAllowPreviewAtECT(
+      *CreateRequest(), PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
   histogram_tester.ExpectUniqueSample(
-      "Previews.EligibilityReason.ClientLoFi",
+      "Previews.EligibilityReason.LoFi",
       static_cast<int>(PreviewsEligibilityReason::ALLOWED), 1);
 }
 
 TEST_F(PreviewsIODataTest, ClientLoFiAllowedOnReload) {
   InitializeUIService();
   CreateFieldTrialWithParams("PreviewsClientLoFi", "Enabled",
                              {{"max_allowed_effective_connection_type", "2G"}});
 
   network_quality_estimator()->set_effective_connection_type(
       net::EFFECTIVE_CONNECTION_TYPE_2G);
 
   std::unique_ptr<net::URLRequest> request = CreateRequest();
   request->SetLoadFlags(net::LOAD_BYPASS_CACHE);
 
   base::HistogramTester histogram_tester;
-  EXPECT_TRUE(
-      io_data()->ShouldAllowPreview(*request, PreviewsType::CLIENT_LOFI));
+  EXPECT_TRUE(io_data()->ShouldAllowPreviewAtECT(
+      *request, PreviewsType::LOFI,
+      params::EffectiveConnectionTypeThresholdForClientLoFi()));
   histogram_tester.ExpectUniqueSample(
-      "Previews.EligibilityReason.ClientLoFi",
+      "Previews.EligibilityReason.LoFi",
       static_cast<int>(PreviewsEligibilityReason::ALLOWED), 1);
 }
 
 }  // namespace
 
 }  // namespace previews