Precache should cancel when there is user traffic

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 <stddef.h>
 #include <stdlib.h>
 
 #include <vector>
@@ skipping 22 matching lines @@
 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/request_source_bandwidth_histograms.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/task_management/task_manager_interface.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/data_usage/core/data_use_aggregator.h"
+#include "components/data_use_measurement/content/data_use_measurement.h"
 #include "components/domain_reliability/monitor.h"
 #include "components/policy/core/browser/url_blacklist_manager.h"
 #include "components/prefs/pref_member.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
@@ skipping 48 matching lines @@
     const net::CompletionCallback& callback,
     net::URLRequest* request,
     GURL* new_url,
     int rv) {
   if (rv == net::OK && new_url->is_empty())
     safe_search_util::ForceGoogleSafeSearch(request, new_url);
   callback.Run(rv);
 }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
-void RecordPrecacheStatsOnUIThread(const GURL& url,
-                                   const GURL& referrer,
-                                   base::TimeDelta latency,
-                                   const base::Time& fetch_time,
-                                   int64_t size,
-                                   bool was_cached,
-                                   void* profile_id) {
+void UpdatePrecacheMetricsAndStateOnUIThread(const GURL& url,
+                                             const GURL& referrer,
+                                             base::TimeDelta latency,
+                                             const base::Time& fetch_time,
+                                             int64_t size,
+                                             bool was_cached,
+                                             bool is_user_traffic,
+                                             void* profile_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!g_browser_process->profile_manager()->IsValidProfile(profile_id))
     return;
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
 
   precache::PrecacheManager* precache_manager =
       precache::PrecacheManagerFactory::GetForBrowserContext(profile);
   // |precache_manager| could be NULL if the profile is off the record.
   if (!precache_manager || !precache_manager->IsPrecachingAllowed())
     return;
 
-  precache_manager->RecordStatsForFetch(url, referrer, latency, fetch_time,
-                                        size, was_cached);
+  precache_manager->UpdatePrecacheMetricsAndState(
+      url, referrer, latency, fetch_time, size, was_cached, is_user_traffic);
 }
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
 
 void ReportInvalidReferrerSendOnUI() {
   base::RecordAction(
       base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer"));
 }
 
 void ReportInvalidReferrerSend(const GURL& target_url,
                                const GURL& referrer_url) {
@@ skipping 390 matching lines @@
     // specified with the Content-Length header, which may be inaccurate,
     // or missing, as is the case with chunked encoding.
     int64_t received_content_length =
         request->received_response_content_length();
     base::TimeDelta latency = base::TimeTicks::Now() - request->creation_time();
 
     // Record precache metrics when a fetch is completed successfully, if
     // precaching is allowed.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&RecordPrecacheStatsOnUIThread, request->url(),
-                   GURL(request->referrer()), latency, base::Time::Now(),
-                   received_content_length, request->was_cached(), profile_));
+        base::Bind(
+            &UpdatePrecacheMetricsAndStateOnUIThread, request->url(),
+            GURL(request->referrer()), latency, base::Time::Now(),
+            received_content_length, request->was_cached(),
+            data_use_measurement::DataUseMeasurement::IsUserTraffic(request),
+            profile_));
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
     extensions_delegate_->OnCompleted(request, started);
   } else if (request->status().status() == net::URLRequestStatus::FAILED ||
              request->status().status() == net::URLRequestStatus::CANCELED) {
     extensions_delegate_->OnCompleted(request, started);
   } else {
     NOTREACHED();
   }
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnCompleted(request, started);
@@ skipping 193 matching lines @@
   if (!data_use_aggregator_)
     return;
 
   if (is_data_usage_off_the_record_) {
     data_use_aggregator_->ReportOffTheRecordDataUse(tx_bytes, rx_bytes);
     return;
   }
 
   data_use_aggregator_->ReportDataUse(request, tx_bytes, rx_bytes);
 }