precache: Add geometric resource weight function.

components/precache/core/precache_fetcher.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 <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 10 matching lines @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/strings/string_piece.h"
 #include "base/task_runner_util.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/precache/core/precache_database.h"
 #include "components/precache/core/precache_switches.h"
-#include "components/precache/core/proto/precache.pb.h"
 #include "components/precache/core/proto/quota.pb.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "net/base/completion_callback.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher_response_writer.h"
@@ skipping 180 matching lines @@
 
 // Returns true if the |quota| time has expired.
 bool IsQuotaTimeExpired(const PrecacheQuota& quota,
                         const base::Time& time_now) {
   // Quota expires one day after the start time.
   base::Time start_time = base::Time::FromInternalValue(quota.start_time());
   return start_time > time_now ||
          start_time + base::TimeDelta::FromDays(1) < time_now;
 }
 
-double ResourceWeight(const PrecacheResource& resource, int64_t host_visits) {
-  return resource.weight_ratio() * host_visits;
+// Models the expected number of requests for the resource, given that
+// resource_weight_ratio is the probability of a request given a visit to the
+// host, and host_visits is the number of visits to the host in 30 days.
+double NaiveResourceWeight(double resource_weight_ratio, int64_t host_visits) {
+  return resource_weight_ratio * host_visits;
+}
+
+// Models the probability of at least one request for the resource, given that
+// resource_weight_ratio is the probability of a request given a visit to the
+// host, and host_visits is the number of visits to the host in 30 days.
+double GeometricResourceWeight(double resource_weight_ratio,
+                               int64_t host_visits) {
+  return 1 - pow(1 - resource_weight_ratio, host_visits);
 }
 
 }  // namespace
 
+// Returns the weight of the resource. When global ranking is enabled, the
+// fetches are sorted by descending weight. Parameters:
+//   function: Which combination function to use.
+//   resource_weight_ratio: The weight_ratio of the resource.
+//   host_visits: The count of visits to the given host in the past 30 days.
+double ResourceWeight(
+    PrecacheConfigurationSettings::ResourceWeightFunction function,
+    double resource_weight_ratio,
+    int64_t host_visits) {
+  switch (function) {
+    case PrecacheConfigurationSettings::FUNCTION_NAIVE:
+      return NaiveResourceWeight(resource_weight_ratio, host_visits);
+    case PrecacheConfigurationSettings::FUNCTION_GEOMETRIC:
+      return GeometricResourceWeight(resource_weight_ratio, host_visits);
+    default:
+      DLOG(FATAL) << "Unknown function " << function;
+      return 0;
+  }
+}
+
 PrecacheFetcher::Fetcher::Fetcher(
     net::URLRequestContextGetter* request_context,
     const GURL& url,
     const std::string& referrer,
     const base::Callback<void(const Fetcher&)>& callback,
     bool is_resource_request,
     size_t max_bytes,
     bool revalidation_only)
     : request_context_(request_context),
       url_(url),
@@ skipping 468 matching lines @@
       const int32_t len =
           std::min(manifest.resource_size(),
                    unfinished_work_->config_settings().top_resources_count());
       const uint64_t resource_bitset =
           GetResourceBitset(manifest, experiment_id_);
       for (int i = 0; i < len; ++i) {
         if (((0x1ULL << i) & resource_bitset) &&
             manifest.resource(i).has_url()) {
           GURL url(manifest.resource(i).url());
           if (url.is_valid()) {
-            double weight = ResourceWeight(manifest.resource(i), host_visits);
+            double weight = ResourceWeight(
+                unfinished_work_->config_settings().resource_weight_function(),
+                manifest.resource(i).weight_ratio(), host_visits);
             if (weight >= unfinished_work_->config_settings().min_weight())
               resources_to_rank_.emplace_back(url, source.referrer(), weight);
           }
         }
       }
       db_task_runner_->PostTask(
           FROM_HERE, base::Bind(&PrecacheDatabase::UpdatePrecacheReferrerHost,
                                 precache_database_, source.referrer(),
                                 manifest.id().id(), base::Time::Now()));
     }
@@ skipping 74 matching lines @@
       remaining = 0;
     quota_.set_remaining(
         used_bytes > quota_.remaining() ? 0U : quota_.remaining() - used_bytes);
     db_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PrecacheDatabase::SaveQuota, precache_database_, quota_));
   }
 }
 
 }  // namespace precache