Precache tracking database

chrome/browser/net/chrome_network_delegate.cc

 // Copyright (c) 2012 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/net/chrome_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
@@ skipping 20 matching lines @@
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/chrome_network_data_saving_metrics.h"
 #include "chrome/browser/net/client_hints.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/load_time_stats.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "components/precache/content/precache_manager.h"
+#include "components/precache/content/precache_manager_factory.h"
+#include "components/precache/core/precache_database.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/common/constants.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/http/http_request_headers.h"
@@ skipping 241 matching lines @@
   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable4Hours",
                        received_content_length);
 
   if (freshness_lifetime.InHours() < 24)
     return;
   UMA_HISTOGRAM_COUNTS("Net.HttpContentLengthCacheable24Hours",
                        received_content_length);
 #endif  // defined(OS_ANDROID)
 }
 
+void RecordPrecacheStatsOnUIThread(void* profile_id, const GURL& url,

[bengr, 2013/10/23 19:03:36]

Why is this a void*? Can it be a const Profile*?

[bengr, 2013/10/23 19:03:36]

To be explicit, I'd wrap this function in #if defined(OS_ANDROID), in addition
to wrapping the caller.

[sclittle, 2013/10/24 22:11:38]

It's a void* because that's what the ChromeNetworkDelegate has. Profiles should
only be used on the UI thread, so we wait until we're on the UI thread before we
cast it into a Profile*. The function NotifyEPMRequestStatus in this file does
it the same way.

We can't make it a const pointer since BrowserContext::GetRequestContext is a
non-const method, and the PrecacheManager needs to call that on the profile when
it constructs the PrecacheFetcher.

[sclittle, 2013/10/24 22:11:38]

Done.

+                                   const base::Time& fetch_time,
+                                   int64 received_content_length,
+                                   bool was_cached) {
+  if (!received_content_length || url.is_empty())
+    return;
+  Profile* profile = reinterpret_cast<Profile*>(profile_id);
+  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+    return;
+  precache::PrecacheManager* precache_manager =
+      precache::PrecacheManagerFactory::GetForBrowserContext(profile);
+  if (!precache_manager)

[bengr, 2013/10/23 19:03:36]

Can this ever happen? How?

[sclittle, 2013/10/24 22:11:38]

This will happen if the profile is incognito.

+    return;
+  scoped_refptr<precache::PrecacheDatabase> precache_database =
+      precache_manager->precache_database();
+  if (!precache_database)

[bengr, 2013/10/23 19:03:36]

Likewise.

[sclittle, 2013/10/24 22:11:38]

This can never happen. Removed if statement.

+    return;
+
+  bool is_cellular = net::NetworkChangeNotifier::IsConnectionCellular(

[bengr, 2013/10/23 19:03:36]

I wonder what fraction is labeled as CONNECTION_UNKNOWN. 

[sclittle, 2013/10/24 22:11:38]

Check out the NCN histograms, including NCN.CM.TimeOnUnknown, NCN.CM.TimeOn2G,
NCN.CM.TimeOn3G, and NCN.CM.TimeOn4G.

+      net::NetworkChangeNotifier::GetConnectionType());
+
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&precache::PrecacheDatabase::RecordURLFetched,
+                 precache_database, url, fetch_time, received_content_length,
+                 was_cached, precache_manager->is_precaching(), is_cellular));
+}
+
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers)
     : event_router_(event_router),
       profile_(NULL),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(NULL),
       force_google_safe_search_(NULL),
@@ skipping 196 matching lines @@
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started) {
   TRACE_EVENT_ASYNC_END0("net", "URLRequest", request);
   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
     // For better accuracy, we use the actual bytes read instead of the length
     // specified with the Content-Length header, which may be inaccurate,
     // or missing, as is the case with chunked encoding.
     int64 received_content_length = request->received_response_content_length();
 
+#if defined(OS_ANDROID)
+    if (precache::PrecacheManager::IsPrecachingEnabled()) {
+      // Record precache statistics for the fetch.
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&RecordPrecacheStatsOnUIThread, profile_, request->url(),
+                     request->response_info().response_time,
+                     received_content_length, request->was_cached()));

[bengr, 2013/10/23 19:03:36]

In what cases does was_cached() return true? Is it true if revalidated and not
changed? Etc.

[sclittle, 2013/10/24 22:11:38]

was_cached() returns true if the response was served from the cache, including
304s. I've verified this manually.

+    }
+#endif  // defined(OS_ANDROID)
+
     // Only record for http or https urls.
     bool is_http = request->url().SchemeIs("http");
     bool is_https = request->url().SchemeIs("https");
 
     if (!request->was_cached() &&         // Don't record cached content
         received_content_length &&        // Zero-byte responses aren't useful.
         (is_http || is_https)) {          // Only record for HTTP or HTTPS urls.
       int64 original_content_length =
           request->response_info().headers->GetInt64HeaderValue(
               "x-original-content-length");
@@ skipping 222 matching lines @@
     int64 received_content_length, int64 original_content_length,
     bool via_data_reduction_proxy) {
   DCHECK_GE(received_content_length, 0);
   DCHECK_GE(original_content_length, 0);
   StoreAccumulatedContentLength(received_content_length,
                                 original_content_length,
                                 via_data_reduction_proxy);
   received_content_length_ += received_content_length;
   original_content_length_ += original_content_length;
 }