precache: Add geometric resource weight function.

components/precache/core/precache_fetcher_unittest.cc

 // Copyright 2013 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/precache/core/precache_fetcher.h"
 
 #include <stdint.h>
 
 #include <cstring>
 #include <memory>
@@ skipping 1403 matching lines @@
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(), std::move(more_work),
         kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
         &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 }
 
-TEST_F(PrecacheFetcherTest, GloballyRankResources) {
+TEST(PrecacheFetcherResourceWeightTest, Naive) {
+  ASSERT_EQ(
+      0, ResourceWeight(PrecacheConfigurationSettings::FUNCTION_NAIVE, 0, 100));
+  ASSERT_EQ(
+      4, ResourceWeight(PrecacheConfigurationSettings::FUNCTION_NAIVE, 1, 4));
+  ASSERT_EQ(8, ResourceWeight(PrecacheConfigurationSettings::FUNCTION_NAIVE,
+                              0.5, 16));
+}
+
+TEST(PrecacheFetcherResourceWeightTest, Geometric) {
+  ASSERT_EQ(0, ResourceWeight(PrecacheConfigurationSettings::FUNCTION_GEOMETRIC,
+                              0, 100));
+  ASSERT_EQ(1, ResourceWeight(PrecacheConfigurationSettings::FUNCTION_GEOMETRIC,
+                              1, 4));
+  ASSERT_NEAR(0.9999847,
+              ResourceWeight(PrecacheConfigurationSettings::FUNCTION_GEOMETRIC,
+                             0.5, 16),
+              0.0000001);
+}
+
+class PrecacheFetcherGlobalRankingTest
+    : public PrecacheFetcherTest,
+      public testing::WithParamInterface<
+          PrecacheConfigurationSettings::ResourceWeightFunction> {};
+
+TEST_P(PrecacheFetcherGlobalRankingTest, GloballyRankResources) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(kNumTopHosts);
   config.set_global_ranking(true);
+  config.set_resource_weight_function(GetParam());
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
@@ skipping 13 matching lines @@
     for (size_t j = 0; j < kNumResources; ++j) {
       const float weight = 1 - static_cast<float>(j) / kNumResources;
       const std::string resource_url =
           base::StringPrintf("http://top-host-%zu.com/resource-%zu-weight-%.1f",
                              i, j, top_host->visits() * weight);
       PrecacheResource* resource = manifest.add_resource();
       resource->set_url(resource_url);
       resource->set_weight_ratio(weight);
       factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
                                net::URLRequestStatus::SUCCESS);
-      resources.emplace_back(resource_url,
-                             top_host->visits() * resource->weight_ratio());
+      resources.emplace_back(
+          resource_url, ResourceWeight(GetParam(), weight, top_host->visits()));
     }
     factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host_url),
                              manifest.SerializeAsString(), net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
   }
   // Sort by descending weight.
   std::stable_sort(resources.begin(), resources.end(),
                    [](const std::pair<std::string, float>& a,
                       const std::pair<std::string, float>& b) {
                      return a.second > b.second;
                    });
   for (const auto& resource : resources)
     expected_requested_urls.emplace_back(resource.first);
 
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
+INSTANTIATE_TEST_CASE_P(
+    PrecacheFetcherGlobalRankingTest,
+    PrecacheFetcherGlobalRankingTest,
+    testing::Values(PrecacheConfigurationSettings::FUNCTION_NAIVE,
+                    PrecacheConfigurationSettings::FUNCTION_GEOMETRIC));
+
 TEST_F(PrecacheFetcherTest, GloballyRankResourcesAfterPauseResume) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(kNumTopHosts);
@@ skipping 398 matching lines @@
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 2);
   histogram.ExpectTotalCount("Precache.Fetch.ResponseBytes.Total", 2);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 2);
 }
 
 }  // namespace precache