Add Precache.Fetch.MinWeight UMA.

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 401 matching lines @@
                     num_total_resources));
 
   UMA_HISTOGRAM_PERCENTAGE("Precache.Fetch.PercentCompleted",
                            percent_completed);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Precache.Fetch.ResponseBytes.Total",
                               unfinished_work.total_bytes(), 1,
                               kMaxResponseBytes, 100);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Precache.Fetch.ResponseBytes.Network",
                               unfinished_work.network_bytes(), 1,
                               kMaxResponseBytes, 100);
+
+  if (unfinished_work.has_min_weight_fetched()) {
+    UMA_HISTOGRAM_COUNTS_1000("Precache.Fetch.MinWeight",
+                              unfinished_work.min_weight_fetched() * 1000);
+  }
 }
 
 // static
 std::string PrecacheFetcher::GetResourceURLBase64HashForTesting(
     const std::vector<GURL>& urls) {
   return GetResourceURLBase64Hash(urls);
 }
 
 PrecacheFetcher::PrecacheFetcher(
     net::URLRequestContextGetter* request_context,
@@ skipping 19 matching lines @@
       << "Could not determine the precache config settings URL.";
   DCHECK_NE(std::string(), GetDefaultManifestURLPrefix())
       << "Could not determine the default precache manifest URL prefix.";
   DCHECK(unfinished_work);
 
   // Copy resources to member variable as a convenience.
   // TODO(rajendrant): Consider accessing these directly from the proto, by
   // keeping track of the current resource index.
   for (const auto& resource : unfinished_work->resource()) {
     if (resource.has_url() && resource.has_top_host_name()) {
-      // Weight doesn't matter, as the resources have already been sorted by
-      // this point.
-      resources_to_fetch_.emplace_back(GURL(resource.url()),
-                                       resource.top_host_name(), 0);
+      resources_to_fetch_.emplace_back(
+          GURL(resource.url()), resource.top_host_name(), resource.weight());
     }
   }
   unfinished_work_ = std::move(unfinished_work);
 }
 
 PrecacheFetcher::~PrecacheFetcher() {
 }
 
 std::unique_ptr<PrecacheUnfinishedWork> PrecacheFetcher::CancelPrecaching() {
   // This could get called multiple times, and it should be handled gracefully.
   if (!unfinished_work_)
     return nullptr;
 
   unfinished_work_->clear_resource();
   if (unfinished_work_->has_config_settings()) {
     // If config fetch is incomplete, |top_hosts_to_fetch_| will be empty and
     // top hosts should be left as is in |unfinished_work_|.
     unfinished_work_->clear_top_host();
     for (const auto& top_host : top_hosts_fetching_)
       unfinished_work_->add_top_host()->set_hostname(top_host.hostname);
     for (const auto& top_host : top_hosts_to_fetch_)
       unfinished_work_->add_top_host()->set_hostname(top_host.hostname);
   }
   for (const auto& resource : resources_fetching_) {
     auto new_resource = unfinished_work_->add_resource();
     new_resource->set_url(resource.url.spec());
     new_resource->set_top_host_name(resource.referrer);
+    new_resource->set_weight(resource.weight);
   }
   for (const auto& resource : resources_to_fetch_) {
     auto new_resource = unfinished_work_->add_resource();
     new_resource->set_url(resource.url.spec());
     new_resource->set_top_host_name(resource.referrer);
+    new_resource->set_weight(resource.weight);
   }
   top_hosts_fetching_.clear();
   top_hosts_to_fetch_.clear();
   resources_fetching_.clear();
   resources_to_fetch_.clear();
   pool_.DeleteAll();
   return std::move(unfinished_work_);
 }
 
 void PrecacheFetcher::Start() {
@@ skipping 47 matching lines @@
         request_context_.get(), top_host.manifest_url, top_host.hostname,
         base::Bind(&PrecacheFetcher::OnManifestFetchComplete, AsWeakPtr(),
                    top_host.visits),
         false /* is_resource_request */, std::numeric_limits<int32_t>::max(),
         false /* revalidation_only */));
     top_hosts_fetching_.push_back(std::move(top_host));
     top_hosts_to_fetch_.pop_front();
   }
 }
 
-void PrecacheFetcher::NotifyDone(
-    size_t remaining_manifest_urls_to_fetch,
-    size_t remaining_resource_urls_to_fetch) {
+void PrecacheFetcher::NotifyDone(size_t remaining_manifest_urls_to_fetch,
+                                 size_t remaining_resource_urls_to_fetch) {
   RecordCompletionStatistics(*unfinished_work_,
                              remaining_manifest_urls_to_fetch,
                              remaining_resource_urls_to_fetch);
   precache_delegate_->OnDone();
 }
 
 void PrecacheFetcher::StartNextFetch() {
   DCHECK(unfinished_work_->has_config_settings());
 
   // If over the precache total size cap or daily quota, then stop prefetching.
@@ skipping 230 matching lines @@
 
 void PrecacheFetcher::OnResourceFetchComplete(const Fetcher& source) {
   UpdateStats(source.response_bytes(), source.network_response_bytes());
 
   db_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PrecacheDatabase::RecordURLPrefetch, precache_database_,
                  source.url(), source.referrer(), base::Time::Now(),
                  source.was_cached(), source.response_bytes()));
 
-  resources_fetching_.remove_if([&source](const ResourceInfo& resource) {
-    return resource.url == source.url();
-  });
+  auto resource =
+      std::find_if(resources_fetching_.begin(), resources_fetching_.end(),
+                   [&source](const ResourceInfo& resource) {
+                     return resource.url == source.url();
+                   });
+  if (resource != resources_fetching_.end()) {
+    if (unfinished_work_->config_settings().global_ranking() &&
+        (!unfinished_work_->has_min_weight_fetched() ||
+         resource->weight < unfinished_work_->min_weight_fetched()))
+      unfinished_work_->set_min_weight_fetched(resource->weight);
+
+    resources_fetching_.erase(resource);
+  }
 
   pool_.Delete(source);
 
   // The resource has already been put in the cache during the fetch process, so
   // nothing more needs to be done for the resource.
   StartNextFetch();
 }
 
 void PrecacheFetcher::UpdateStats(int64_t response_bytes,
                                   int64_t network_response_bytes) {
@@ skipping 13 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