Add PLT measurement to Resource Prefetching for Mobile Web

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_db_task.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/mime_util.h"
+#include "net/base/network_change_notifier.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // For reporting whether a subresource is handled or not, and for what reasons.
 enum ResourceStatus {
@@ skipping 36 matching lines @@
   REPORTING_EVENT_PARTIAL_HISTORY_CLEARED = 1,
   REPORTING_EVENT_COUNT = 2
 };
 
 void RecordNavigationEvent(NavigationEvent event) {
   UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
                             event,
                             NAVIGATION_EVENT_COUNT);
 }
 
+// These are additional connection types for
+// net::NetworkChangeNotifier::ConnectionType. They have negative values in case
+// the original network connection types expand.
+enum AdditionalConnectionType {
+  CONNECTION_ALL = -2,
+  CONNECTION_CELLULAR = -1
+};
+
+std::string GetNetTypeStr() {
+  switch (net::NetworkChangeNotifier::GetConnectionType()) {
+    case net::NetworkChangeNotifier::CONNECTION_ETHERNET:
+      return "Ethernet";
+    case net::NetworkChangeNotifier::CONNECTION_WIFI:
+      return "WiFi";
+    case net::NetworkChangeNotifier::CONNECTION_2G:
+      return "2G";
+    case net::NetworkChangeNotifier::CONNECTION_3G:
+      return "3G";
+    case net::NetworkChangeNotifier::CONNECTION_4G:
+      return "4G";
+    case net::NetworkChangeNotifier::CONNECTION_NONE:
+      return "None";
+    case net::NetworkChangeNotifier::CONNECTION_BLUETOOTH:
+      return "Bluetooth";
+    case net::NetworkChangeNotifier::CONNECTION_UNKNOWN:
+    default:
+      break;
+  }
+  return "Unknown";
+}
+
+void ReportPrefetchedNetworkType(int type) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY(
+      "ResourcePrefetchPredictor.NetworkType.Prefetched",
+      type);
+}
+
+void ReportNotPrefetchedNetworkType(int type) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY(
+      "ResourcePrefetchPredictor.NetworkType.NotPrefetched",
+      type);
+}
+
 }  // namespace
 
 namespace predictors {
 
 ////////////////////////////////////////////////////////////////////////////////
 // History lookup task.
 
 // Used to fetch the visit count for a URL from the History database.
 class GetUrlVisitCountTask : public history::HistoryDBTask {
  public:
@@ skipping 415 matching lines @@
 
   NavigationMap::iterator nav_it =
       inflight_navigations_.find(navigation_id);
   if (nav_it == inflight_navigations_.end()) {
     RecordNavigationEvent(NAVIGATION_EVENT_ONLOAD_UNTRACKED_URL);
     return;
   }
   RecordNavigationEvent(NAVIGATION_EVENT_ONLOAD_TRACKED_URL);
 
   // Report any stats.
+  base::TimeDelta plt = base::TimeTicks::Now() - navigation_id.creation_time;
+  ReportPageLoadTimeStats(plt);
   if (prefetch_manager_.get()) {
     ResultsMap::iterator results_it = results_map_.find(navigation_id);
     bool have_prefetch_results = results_it != results_map_.end();
     UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.HavePrefetchResults",
                           have_prefetch_results);
     if (have_prefetch_results) {
       ReportAccuracyStats(results_it->second->key_type,
                           *(nav_it->second),
                           results_it->second->requests.get());
+      ReportPageLoadTimePrefetchStats(
+          plt,
+          true,
+          base::Bind(&ReportPrefetchedNetworkType),
+          results_it->second->key_type);
+    } else {
+      ReportPageLoadTimePrefetchStats(
+          plt,
+          false,
+          base::Bind(&ReportNotPrefetchedNetworkType),
+          PREFETCH_KEY_TYPE_URL);
     }
   } else {
     scoped_ptr<ResourcePrefetcher::RequestVector> requests(
         new ResourcePrefetcher::RequestVector);
     PrefetchKeyType key_type;
     if (GetPrefetchData(navigation_id, requests.get(), &key_type)) {
       RecordNavigationEvent(NAVIGATION_EVENT_HAVE_PREDICTIONS_FOR_URL);
       ReportPredictedAccuracyStats(key_type,
                                    *(nav_it->second),
                                    *requests);
@@ skipping 449 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&ResourcePrefetchPredictorTables::UpdateData,
                    tables_,
                    url_data,
                    host_data));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Accuracy measurement.
+// Page load time and accuracy measurement.
+
+// This is essentially UMA_HISTOGRAM_MEDIUM_TIMES, but it avoids using the
+// STATIC_HISTOGRAM_POINTER_BLOCK in UMA_HISTOGRAM definitions.
+#define RPP_HISTOGRAM_MEDIUM_TIMES(name, page_load_time) \
+  do { \
+    base::HistogramBase* histogram = base::Histogram::FactoryTimeGet( \
+        name, \
+        base::TimeDelta::FromMilliseconds(10), \
+        base::TimeDelta::FromMinutes(3), \
+        50, \
+        base::HistogramBase::kUmaTargetedHistogramFlag); \
+    histogram->AddTime(page_load_time); \
+  } while (0)
+
+void ResourcePrefetchPredictor::ReportPageLoadTimeStats(
+    base::TimeDelta plt) const {
+  net::NetworkChangeNotifier::ConnectionType connection_type =
+      net::NetworkChangeNotifier::GetConnectionType();
+
+  RPP_HISTOGRAM_MEDIUM_TIMES("ResourcePrefetchPredictor.PLT", plt);
+  RPP_HISTOGRAM_MEDIUM_TIMES(
+      "ResourcePrefetchPredictor.PLT_" + GetNetTypeStr(), plt);
+  if (net::NetworkChangeNotifier::IsConnectionCellular(connection_type))
+    RPP_HISTOGRAM_MEDIUM_TIMES("ResourcePrefetchPredictor.PLT_Cellular", plt);
+}
+
+void ResourcePrefetchPredictor::ReportPageLoadTimePrefetchStats(
+    base::TimeDelta plt,
+    bool prefetched,
+    base::Callback<void(int)> report_network_type_callback,
+    PrefetchKeyType key_type) const {
+  net::NetworkChangeNotifier::ConnectionType connection_type =
+      net::NetworkChangeNotifier::GetConnectionType();
+  bool on_cellular =
+      net::NetworkChangeNotifier::IsConnectionCellular(connection_type);
+
+  report_network_type_callback.Run(CONNECTION_ALL);
+  report_network_type_callback.Run(connection_type);
+  if (on_cellular)
+    report_network_type_callback.Run(CONNECTION_CELLULAR);
+
+  std::string prefetched_str;
+  if (prefetched)
+    prefetched_str = "Prefetched";
+  else
+    prefetched_str = "NotPrefetched";
+
+  RPP_HISTOGRAM_MEDIUM_TIMES(
+      "ResourcePrefetchPredictor.PLT." + prefetched_str, plt);
+  RPP_HISTOGRAM_MEDIUM_TIMES(
+      "ResourcePrefetchPredictor.PLT." + prefetched_str + "_" + GetNetTypeStr(),
+      plt);
+  if (on_cellular) {
+    RPP_HISTOGRAM_MEDIUM_TIMES(
+        "ResourcePrefetchPredictor.PLT." + prefetched_str + "_Cellular", plt);
+  }
+
+  if (!prefetched)
+    return;
+
+  std::string type =
+      key_type == PREFETCH_KEY_TYPE_HOST ? "Host" : "Url";
+  RPP_HISTOGRAM_MEDIUM_TIMES(
+      "ResourcePrefetchPredictor.PLT.Prefetched." + type, plt);
+  RPP_HISTOGRAM_MEDIUM_TIMES(
+      "ResourcePrefetchPredictor.PLT.Prefetched." + type + "_"
+          + GetNetTypeStr(),
+      plt);
+  if (on_cellular) {
+    RPP_HISTOGRAM_MEDIUM_TIMES(
+        "ResourcePrefetchPredictor.PLT.Prefetched." + type + "_Cellular",
+        plt);
+  }
+}
 
 void ResourcePrefetchPredictor::ReportAccuracyStats(
     PrefetchKeyType key_type,
     const std::vector<URLRequestSummary>& actual,
     ResourcePrefetcher::RequestVector* prefetched) const {
   // Annotate the results.
   std::map<GURL, bool> actual_resources;
   for (std::vector<URLRequestSummary>::const_iterator it = actual.begin();
        it != actual.end(); ++it) {
     actual_resources[it->resource_url] = it->was_cached;
@@ skipping 193 matching lines @@
       prefetch_network * 100.0 / num_assumed_prefetched);
 
   // Measure the ratio of total number of resources prefetched from network vs
   // the total number of resources fetched by the page from the network.
   if (total_resources_fetched_from_network > 0) {
     RPP_PREDICTED_HISTOGRAM_PERCENTAGE(
         "PrefetchFromNetworkPercentOfTotalFromNetwork",
         prefetch_network * 100.0 / total_resources_fetched_from_network);
   }
 
+#undef RPP_HISTOGRAM_MEDIUM_TIMES
 #undef RPP_PREDICTED_HISTOGRAM_PERCENTAGE
 #undef RPP_PREDICTED_HISTOGRAM_COUNTS
 }
 
 }  // namespace predictors