Add UMA Precache.Freshness.Prefetch

components/precache/content/precache_manager.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/content/precache_manager.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/precache/core/precache_database.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync_driver/sync_service.h"
 #include "components/variations/metrics_util.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/network_change_notifier.h"
+#include "net/http/http_response_info.h"

[bengr, 2016/07/21 00:03:27]

Remove this include. You will forward declare in the .h

[jamartin, 2016/07/25 23:23:07]

Done.

 
 using content::BrowserThread;
 
 namespace {
 
 const char kPrecacheFieldTrialName[] = "Precache";
 const char kPrecacheFieldTrialEnabledGroup[] = "Enabled";
 const char kPrecacheFieldTrialControlGroup[] = "Control";
 const char kConfigURLParam[] = "config_url";
 const char kManifestURLPrefixParam[] = "manifest_url_prefix";
@@ skipping 173 matching lines @@
 bool PrecacheManager::IsPrecaching() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return is_precaching_;
 }
 
 void PrecacheManager::UpdatePrecacheMetricsAndState(
     const GURL& url,
     const GURL& referrer,
     const base::TimeDelta& latency,
     const base::Time& fetch_time,
+    const net::HttpResponseInfo& info,
     int64_t size,
-    bool was_cached,
     bool is_user_traffic) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  RecordStatsForFetch(url, referrer, latency, fetch_time, size, was_cached);
+  RecordStatsForFetch(url, referrer, latency, fetch_time, info, size);
   if (is_user_traffic && IsPrecaching())
     CancelPrecaching();
 }
 
 void PrecacheManager::RecordStatsForFetch(const GURL& url,
                                           const GURL& referrer,
                                           const base::TimeDelta& latency,
                                           const base::Time& fetch_time,
-                                          int64_t size,
-                                          bool was_cached) {
+                                          const net::HttpResponseInfo& info,
+                                          int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (size == 0 || url.is_empty() || !url.SchemeIsHTTPOrHTTPS()) {
     // Ignore empty responses, empty URLs, or URLs that aren't HTTP or HTTPS.
     return;
   }
 
   if (!history_service_)
     return;
 
   history_service_->HostRankIfAvailable(
-      referrer,
-      base::Bind(&PrecacheManager::RecordStatsForFetchInternal, AsWeakPtr(),
-                 url, latency, fetch_time, size, was_cached));
+      referrer, base::Bind(&PrecacheManager::RecordStatsForFetchInternal,
+                           AsWeakPtr(), url, latency, fetch_time, info, size));
 }
 
 void PrecacheManager::RecordStatsForFetchInternal(
     const GURL& url,
     const base::TimeDelta& latency,
     const base::Time& fetch_time,
+    const net::HttpResponseInfo& info,
     int64_t size,
-    bool was_cached,
     int host_rank) {
   if (is_precaching_) {
     // Assume that precache is responsible for all requests made while
     // precaching is currently in progress.
     // TODO(sclittle): Make PrecacheFetcher explicitly mark precache-motivated
     // fetches, and use that to determine whether or not a fetch was motivated
     // by precaching.
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&PrecacheDatabase::RecordURLPrefetch,
                    base::Unretained(precache_database_.get()), url, latency,
-                   fetch_time, size, was_cached));
+                   fetch_time, info, size));
   } else {
     bool is_connection_cellular =
         net::NetworkChangeNotifier::IsConnectionCellular(
             net::NetworkChangeNotifier::GetConnectionType());
 
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&PrecacheDatabase::RecordURLNonPrefetch,
                    base::Unretained(precache_database_.get()), url, latency,
-                   fetch_time, size, was_cached, host_rank,
-                   is_connection_cellular));
+                   fetch_time, info, size, host_rank, is_connection_cellular));
   }
 }
 
 void PrecacheManager::ClearHistory() {
   // PrecacheDatabase::ClearHistory must run after PrecacheDatabase::Init has
   // finished. Using PostNonNestableTask guarantees this, by definition. See
   // base::SequencedTaskRunner for details.
   BrowserThread::PostNonNestableTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&PrecacheDatabase::ClearHistory,
@@ skipping 50 matching lines @@
       this));
   precache_fetcher_->Start();
 }
 
 void PrecacheManager::OnHostsReceivedThenDone(
     const history::TopHostsList& host_counts) {
   OnDone();
 }
 
 }  // namespace precache