Add Precache.CacheStatus.NonPrefetch.FromPrecache.

components/precache/core/precache_database.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_database.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 180 matching lines @@
   // Use the URL table to keep track of URLs. URLs that are fetched via network
   // or already in the cache due to prior precaching are recorded as
   // precache-motivated. URLs that came from the cache and not recorded as
   // precached previously, were already in the cache because of user browsing.
   // Therefore, this precache will not be considered as precache-motivated,
   // since it had no significant effect (besides a possible revalidation and a
   // change in the cache LRU priority). If a row for the URL already exists,
   // then the timestamp is updated.
   buffered_writes_.push_back(base::Bind(
       &PrecacheDatabase::RecordURLPrefetchInternal, GetWeakPtr(), url,
-      referrer_host, !was_cached || precache_url_table_.IsURLPrecached(url),
+      referrer_host,
+      !was_cached || precache_url_table_.GetURLInfo(url).is_precached,
       fetch_time));
   buffered_urls_.insert(url.spec());
   MaybePostFlush();
 }
 
 void PrecacheDatabase::RecordURLPrefetchInternal(
     const GURL& url,
     const std::string& referrer_host,
     bool is_precached,
     const base::Time& fetch_time) {
@@ skipping 31 matching lines @@
   }
 
   RecordTimeSinceLastPrecache(fetch_time);
 
   if (buffered_urls_.find(url.spec()) != buffered_urls_.end()) {
     // If the URL for this fetch is in the write buffer, then flush the write
     // buffer.
     Flush();
   }
 
-  bool is_precached = precache_url_table_.IsURLPrecachedAndUnused(url);
-  if (info.was_cached && !is_precached) {
-    // Ignore cache hits that precache can't take credit for.
-    return;
+  const PrecacheURLInfo url_info = precache_url_table_.GetURLInfo(url);
+
+  if (url_info.was_precached) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Precache.CacheStatus.NonPrefetch.FromPrecache",
+        info.cache_entry_status,
+        net::HttpResponseInfo::CacheEntryStatus::ENTRY_MAX);
   }
 
   base::HistogramBase::Sample size_sample =
       static_cast<base::HistogramBase::Sample>(size);
   if (!info.was_cached) {
     // The fetch was served over the network during user browsing, so count it
     // as downloaded non-precache bytes.
     UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache", size_sample);
     if (is_connection_cellular) {
       UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache.Cellular",
                            size_sample);
     }
     // Since the resource has been fetched during user browsing, mark the URL as
     // used in the precache URL table, if any exists. The current fetch would
     // have put this resource in the cache regardless of whether or not it was
     // previously precached, so mark the URL as used.
     buffered_writes_.push_back(
         base::Bind(&PrecacheURLTable::SetURLAsNotPrecached,
                    base::Unretained(&precache_url_table_), url));
     buffered_urls_.insert(url.spec());
     MaybePostFlush();
-  } else {  // info.was_cached.
+  } else if (/* info.was_cached && */ url_info.is_precached &&
+             !url_info.was_used) {
     // The fetch was served from the cache, and since there's an entry for this
     // URL in the URL table, this means that the resource was served from the
     // cache only because precaching put it there. Thus, precaching was helpful,
     // so count the fetch as saved bytes.
     UMA_HISTOGRAM_COUNTS("Precache.Saved", size_sample);
     if (is_connection_cellular) {
       UMA_HISTOGRAM_COUNTS("Precache.Saved.Cellular", size_sample);
     }
 
     DCHECK(info.headers) << "The headers are required to get the freshness.";
@@ skipping 147 matching lines @@
 
 PrecacheQuota PrecacheDatabase::GetQuota() {
   return precache_session_table_.GetQuota();
 }
 
 base::WeakPtr<PrecacheDatabase> PrecacheDatabase::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace precache