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 34 matching lines @@
 #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"
 #include "net/http/http_response_headers.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/url_request/url_request.h"
 
+#if defined(OS_ANDROID)
+#include "components/precache/content/precache_manager.h"
+#include "components/precache/content/precache_manager_factory.h"
+#include "components/precache/core/precache_database.h"
+#endif
+
 #if defined(OS_CHROMEOS)
 #include "base/command_line.h"
 #include "base/sys_info.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "chrome/browser/policy/url_blacklist_manager.h"
 #endif
 
@@ skipping 227 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)
 }
 
+#if defined(OS_ANDROID)
+
+void RecordPrecacheStatsOnUIThread(void* profile_id, const GURL& url,
+                                   const base::Time& fetch_time,
+                                   int64 received_content_length,
+                                   bool was_cached) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Ignore empty responses and empty URLs.
+  if (!received_content_length || url.is_empty())

[mmenke, 2013/10/31 16:45:00]

Should only do this for HTTP and HTTPS requests, right?

+    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);
+
+  // This will be NULL in incognito mode.
+  if (!precache_manager)
+    return;
+
+  bool is_cellular = net::NetworkChangeNotifier::IsConnectionCellular(
+      net::NetworkChangeNotifier::GetConnectionType());
+
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&precache::PrecacheDatabase::RecordURLFetched,
+                 precache_manager->precache_database(), url, fetch_time,
+                 received_content_length, was_cached,
+                 precache_manager->IsPrecaching(), is_cellular));

[mmenke, 2013/10/31 16:45:00]

Do we really need to get the time from the URL request?  Not strongly opposed,
just not sure passing it around really gets us much over using the time we
record the stat instead.

[mmenke, 2013/10/31 16:45:00]

I don't think the ChromeNetworkDelegate should know or care about the
precache_database - I think we should just pass the URL, time, content length,
and was_cached flag to the PrecacheManager and have it pass it on to the DB, so
this file doesn't depend on it.  Can also then get rid of the database accessor.

Also should move logic about not recording 0-length requests / empty URLs / etc
there.

+}
+
+#endif  // defined(OS_ANDROID)
+
 }  // 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()));
+    }
+#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;
 }