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"

[mmenke, 2013/10/29 18:23:34]

Here and for the other new code, is there no if-def for whether or not we're
being compiled with a particular component?

[sclittle, 2013/10/29 23:40:45]

There isn't any macro that is specifically defined when we're being compiled
with precaching; at the moment we use OS_ANDROID for this.

Should I add a new macro for this that is only defined when OS_ANDROID is
defined?

[mmenke, 2013/10/30 18:29:08]

No, it's fine - I had just thought/hoped that there might be a pre-processor
macro system associated with which components we were being compiled with.

 #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)
 }
 
+#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())
+    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));
+}
+
+#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;
 }