predictors: Introduce GlowplugPredictor.

chrome/browser/predictors/resource_prefetch_common_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 <memory>
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/predictors/resource_prefetch_common.h"
@@ skipping 31 matching lines @@
 namespace predictors {
 
 class ResourcePrefetchCommonTest : public testing::Test {
  public:
   ResourcePrefetchCommonTest();
 
   void SetPreference(NetworkPredictionOptions value) {
     profile_->GetPrefs()->SetInteger(prefs::kNetworkPredictionOptions, value);
   }
 
-  void TestIsPrefetchEnabledForOrigin(
-      const ResourcePrefetchPredictorConfig& config,
-      PrefetchOrigin origin) {
+  void TestIsPrefetchEnabledForOrigin(const LoadingPredictorConfig& config,
+                                      HintOrigin origin) {
     EXPECT_TRUE(config.IsLearningEnabled());
     EXPECT_TRUE(config.IsPrefetchingEnabledForOrigin(profile_.get(), origin));
   }
 
-  void TestIsPrefetchLearning(const ResourcePrefetchPredictorConfig& config) {
+  void TestIsPrefetchLearning(const LoadingPredictorConfig& config) {
     EXPECT_TRUE(config.IsLearningEnabled());
-    EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(
-        profile_.get(), PrefetchOrigin::EXTERNAL));
-    EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(
-        profile_.get(), PrefetchOrigin::NAVIGATION));
+    EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(profile_.get(),
+                                                      HintOrigin::EXTERNAL));
+    EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(profile_.get(),
+                                                      HintOrigin::NAVIGATION));
     EXPECT_GT(config.min_resource_hits_to_trigger_prefetch, 1U);
   }
 
-  void TestIsDefaultExtraConfig(const ResourcePrefetchPredictorConfig& config) {
+  void TestIsDefaultExtraConfig(const LoadingPredictorConfig& config) {
     EXPECT_FALSE(config.IsLowConfidenceForTest());
     EXPECT_FALSE(config.IsHighConfidenceForTest());
     EXPECT_FALSE(config.IsMoreResourcesEnabledForTest());
     EXPECT_FALSE(config.IsSmallDBEnabledForTest());
     EXPECT_FALSE(config.is_url_learning_enabled);
     EXPECT_FALSE(config.is_manifests_enabled);
     EXPECT_FALSE(config.is_origin_learning_enabled);
     EXPECT_GT(config.min_resource_hits_to_trigger_prefetch, 1U);
   }
 
  protected:
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   std::unique_ptr<TestingProfile> profile_;
 };
 
 ResourcePrefetchCommonTest::ResourcePrefetchCommonTest()
     : profile_(new TestingProfile()) {}
 
 TEST_F(ResourcePrefetchCommonTest, IsDisabledByDefault) {
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_FALSE(
       IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
 
   EXPECT_FALSE(config.IsLearningEnabled());
   EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(profile_.get(),
-                                                    PrefetchOrigin::EXTERNAL));
-  EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(
-      profile_.get(), PrefetchOrigin::NAVIGATION));
+                                                    HintOrigin::EXTERNAL));
+  EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(profile_.get(),
+                                                    HintOrigin::NAVIGATION));
 
   TestIsDefaultExtraConfig(config);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnableLearning) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial", {{kModeParamName, kLearningMode}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
   TestIsPrefetchLearning(config);
   TestIsDefaultExtraConfig(config);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnablePrefetch) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial", {{kModeParamName, kPrefetchingMode}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
-  TestIsPrefetchEnabledForOrigin(config, PrefetchOrigin::EXTERNAL);
-  TestIsPrefetchEnabledForOrigin(config, PrefetchOrigin::NAVIGATION);
+  TestIsPrefetchEnabledForOrigin(config, HintOrigin::EXTERNAL);
+  TestIsPrefetchEnabledForOrigin(config, HintOrigin::NAVIGATION);
   TestIsDefaultExtraConfig(config);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnablePrefetchExternalOnly) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial", {{kModeParamName, kExternalPrefetchingMode}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
-  TestIsPrefetchEnabledForOrigin(config, PrefetchOrigin::EXTERNAL);
-  EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(
-      profile_.get(), PrefetchOrigin::NAVIGATION));
+  TestIsPrefetchEnabledForOrigin(config, HintOrigin::EXTERNAL);
+  EXPECT_FALSE(config.IsPrefetchingEnabledForOrigin(profile_.get(),
+                                                    HintOrigin::NAVIGATION));
   TestIsDefaultExtraConfig(config);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnableUrlLearning) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial",
       {{kModeParamName, kLearningMode}, {kEnableUrlLearningParamName, "true"}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
   TestIsPrefetchLearning(config);
   EXPECT_TRUE(config.is_url_learning_enabled);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnableManifests) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial",
       {{kModeParamName, kLearningMode}, {kEnableManifestsParamName, "true"}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
   TestIsPrefetchLearning(config);
   EXPECT_TRUE(config.is_manifests_enabled);
 }
 
 TEST_F(ResourcePrefetchCommonTest, EnableOriginLearning) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial",
       {{kModeParamName, kLearningMode},
        {kEnableOriginLearningParamName, "true"}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
   TestIsPrefetchLearning(config);
   EXPECT_TRUE(config.is_origin_learning_enabled);
 }
 
 // Verifies whether prefetching is disabled according to the network type. But
 // learning should not be disabled by network.
 TEST_F(ResourcePrefetchCommonTest, RespectsNetworkSettings) {
   variations::testing::VariationParamsManager params_manager(
       "dummy-trial", {{kModeParamName, kPrefetchingMode}},
       {kSpeculativeResourcePrefetchingFeatureName});
 
-  ResourcePrefetchPredictorConfig config;
+  LoadingPredictorConfig config;
   EXPECT_TRUE(IsSpeculativeResourcePrefetchingEnabled(profile_.get(), &config));
-  TestIsPrefetchEnabledForOrigin(config, PrefetchOrigin::EXTERNAL);
+  TestIsPrefetchEnabledForOrigin(config, HintOrigin::EXTERNAL);
   TestIsDefaultExtraConfig(config);
 
   // Set preference to WIFI_ONLY: prefetch when not on cellular.
   SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_WIFI_ONLY);
   {
     std::unique_ptr<NetworkChangeNotifier> mock(
         new MockNetworkChangeNotifierWIFI);
-    TestIsPrefetchEnabledForOrigin(config, PrefetchOrigin::EXTERNAL);
+    TestIsPrefetchEnabledForOrigin(config, HintOrigin::EXTERNAL);
   }
   {
     std::unique_ptr<NetworkChangeNotifier> mock(
         new MockNetworkChangeNotifier4G);
     TestIsPrefetchLearning(config);
   }
 
   // Set preference to NEVER: never prefetch.
   SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_NEVER);
   {
     std::unique_ptr<NetworkChangeNotifier> mock(
         new MockNetworkChangeNotifierWIFI);
     TestIsPrefetchLearning(config);
   }
   {
     std::unique_ptr<NetworkChangeNotifier> mock(
         new MockNetworkChangeNotifier4G);
     TestIsPrefetchLearning(config);
   }
 }
 
 }  // namespace predictors