Move data use measurement to DataUseNetworkDelegate

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 125 matching lines @@
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "Net.HttpRequestCompletionErrorCodes.MainFrame", std::abs(net_error));
     }
   }
 }
 
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
-    BooleanPrefMember* enable_referrers,
-    const metrics::UpdateUsagePrefCallbackType& metrics_data_use_forwarder)
+    BooleanPrefMember* enable_referrers)
     : profile_(nullptr),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(nullptr),
       force_google_safe_search_(nullptr),
       force_youtube_restrict_(nullptr),
       allowed_domains_for_apps_(nullptr),
       url_blacklist_manager_(nullptr),
       domain_reliability_monitor_(nullptr),
-      data_use_measurement_(metrics_data_use_forwarder),
       experimental_web_platform_features_enabled_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnableExperimentalWebPlatformFeatures)),
       data_use_aggregator_(nullptr),
       is_data_usage_off_the_record_(true) {
   DCHECK(enable_referrers);
   extensions_delegate_.reset(
       ChromeExtensionsNetworkDelegate::Create(event_router));
 }
 
@@ skipping 62 matching lines @@
 
 int ChromeNetworkDelegate::OnBeforeURLRequest(
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   // TODO(mmenke): Remove ScopedTracker below once crbug.com/456327 is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "456327 URLRequest::ChromeNetworkDelegate::OnBeforeURLRequest"));
 
-  data_use_measurement_.OnBeforeURLRequest(request);
-
   // TODO(joaodasilva): This prevents extensions from seeing URLs that are
   // blocked. However, an extension might redirect the request to another URL,
   // which is not blocked.
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   int error = net::ERR_BLOCKED_BY_ADMINISTRATOR;
   if (info && content::IsResourceTypeFrame(info->GetResourceType()) &&
       url_blacklist_manager_ &&
       url_blacklist_manager_->ShouldBlockRequestForFrame(
           request->url(), &error)) {
@@ skipping 94 matching lines @@
   return extensions_delegate_->OnHeadersReceived(
       request,
       callback,
       original_response_headers,
       override_response_headers,
       allowed_unsafe_redirect_url);
 }
 
 void ChromeNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
                                              const GURL& new_location) {
-  data_use_measurement_.OnBeforeRedirect(*request, new_location);
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnBeforeRedirect(request);
   extensions_delegate_->OnBeforeRedirect(request, new_location);
 }
 
 void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request,
                                               int net_error) {
   extensions_delegate_->OnResponseStarted(request, net_error);
 }
 
 void ChromeNetworkDelegate::OnNetworkBytesReceived(net::URLRequest* request,
                                                    int64_t bytes_received) {
 #if defined(ENABLE_TASK_MANAGER)
   // Note: Currently, OnNetworkBytesReceived is only implemented for HTTP jobs,
   // not FTP or other types, so those kinds of bytes will not be reported here.
   task_manager::TaskManagerInterface::OnRawBytesRead(*request, bytes_received);
 #endif  // defined(ENABLE_TASK_MANAGER)
 
   ReportDataUsageStats(request, 0 /* tx_bytes */, bytes_received);
-  data_use_measurement_.OnNetworkBytesReceived(*request, bytes_received);
 }
 
 void ChromeNetworkDelegate::OnNetworkBytesSent(net::URLRequest* request,
                                                int64_t bytes_sent) {
   ReportDataUsageStats(request, bytes_sent, 0 /* rx_bytes */);
-  data_use_measurement_.OnNetworkBytesSent(*request, bytes_sent);
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started,
                                         int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
   // TODO(amohammadkhan): Verify that there is no double recording in data use
   // of redirected requests.
-  data_use_measurement_.OnCompleted(*request, started);
   RecordNetworkErrorHistograms(request, net_error);
 
   if (net_error == net::OK) {
 #if BUILDFLAG(ANDROID_JAVA_UI)
     precache::UpdatePrecacheMetricsAndState(request, profile_);
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
   }
 
   extensions_delegate_->OnCompleted(request, started, net_error);
   if (domain_reliability_monitor_)
@@ skipping 181 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);
 }