TaskManager: use an unordered_map for tracking network usage

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 333 matching lines @@
 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(OS_ANDROID)
   // 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);
+
+  // Only net::URLRequestJob instances created by the ResourceDispatcherHost
+  // have an associated ResourceRequestInfo and a render frame associated.
+  // All other jobs will have -1 returned for the render process child and
+  // routing ids - the jobs may still match a resource based on their origin id,
+  // otherwise BytesRead() will attribute the activity to the Browser resource.
+  const content::ResourceRequestInfo* info =
+      content::ResourceRequestInfo::ForRequest(request);
+  int child_id = -1;
+  int route_id = -1;
+
+  if (info)
+    info->GetAssociatedRenderFrame(&child_id, &route_id);
+
+  // Get the origin PID of the request's originator.  This will only be set for
+  // plugins - for renderer or browser initiated requests it will be zero.
+  int origin_pid = info ? info->GetOriginPID() : 0;
+  task_manager::BytesTransferredKey key = {origin_pid, child_id, route_id};
+  int64_t bytes_sent = 0;
+  task_manager::TaskManagerInterface::OnRawBytesTransferred(key, bytes_received,
+                                                            bytes_sent);
 #endif  // !defined(OS_ANDROID)
 
   ReportDataUsageStats(request, 0 /* tx_bytes */, bytes_received);
 }
 
 void ChromeNetworkDelegate::OnNetworkBytesSent(net::URLRequest* request,
                                                int64_t bytes_sent) {
 #if !defined(OS_ANDROID)
   // Note: Currently, OnNetworkBytesSent is only implemented for HTTP jobs,
   // not FTP or other types, so those kinds of bytes will not be reported here.
-  task_manager::TaskManagerInterface::OnRawBytesSent(*request, bytes_sent);
+
+  // Only net::URLRequestJob instances created by the ResourceDispatcherHost
+  // have an associated ResourceRequestInfo and a render frame associated.
+  // All other jobs will have -1 returned for the render process child and
+  // routing ids - the jobs may still match a resource based on their origin id,
+  // otherwise BytesRead() will attribute the activity to the Browser resource.
+  const content::ResourceRequestInfo* info =
+      content::ResourceRequestInfo::ForRequest(request);
+  int child_id = -1;
+  int route_id = -1;
+
+  if (info)
+    info->GetAssociatedRenderFrame(&child_id, &route_id);
+
+  // Get the origin PID of the request's originator.  This will only be set for
+  // plugins - for renderer or browser initiated requests it will be zero.
+  int origin_pid = info ? info->GetOriginPID() : 0;
+  task_manager::BytesTransferredKey key = {origin_pid, child_id, route_id};
+  int bytes_received = 0;
+  task_manager::TaskManagerInterface::OnRawBytesTransferred(key, bytes_received,

[ncarter (slow), 2017/06/29 23:40:00]

Let's adjust this layering slightly. It shouldn't be chrome_network_delegate's
job to unpack its struct into a task_manager::BytesTransferredKey. Constructing
the BytesTransferredKey is 'business logic' that belongs inside the TaskManager.

Since the unit tests are written terms of
TaskManagerIoThreadHelper::OnRawBytesTransferred (and not in terms of the
task_manager::TaskManagerInterface static methods), I think you can actually
revert the changes to this file, and move the unpacking inside of
TaskManagerInterface::OnRawBytesRead and TaskManagerInterface::OnRawBytesSent. 

By leaving the chrome/browser/net files untouched, we won't need anything but a
task_manager OWNER to approve this change.

[cburn, 2017/06/30 18:04:38]

Done. That is a much better solution. 

+                                                            bytes_sent);
 #endif  // !defined(OS_ANDROID)
 
   ReportDataUsageStats(request, bytes_sent, 0 /* rx_bytes */);
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started,
                                         int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
@@ skipping 231 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);
 }