plumb network upload into the task manager

chrome/browser/task_manager/sampling/task_manager_impl.cc

 // Copyright 2015 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/task_manager/sampling/task_manager_impl.h"
 
 #include <algorithm>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ skipping 215 matching lines @@
   return GetTaskByTaskId(task_id)->GetChildProcessUniqueID();
 }
 
 void TaskManagerImpl::GetTerminationStatus(TaskId task_id,
                                            base::TerminationStatus* out_status,
                                            int* out_error_code) const {
   GetTaskByTaskId(task_id)->GetTerminationStatus(out_status, out_error_code);
 }
 
 int64_t TaskManagerImpl::GetNetworkUsage(TaskId task_id) const {
-  return GetTaskByTaskId(task_id)->network_usage();
+  return GetTaskByTaskId(task_id)->network_usage_rate();
+}
+
+int64_t TaskManagerImpl::GetCumulativeNetworkUsage(TaskId task_id) const {
+  return GetTaskByTaskId(task_id)->cumulative_network_usage();
 }
 
 int64_t TaskManagerImpl::GetProcessTotalNetworkUsage(TaskId task_id) const {
-  return GetTaskGroupByTaskId(task_id)->per_process_network_usage();
+  return GetTaskGroupByTaskId(task_id)->per_process_network_usage_rate();
+}
+
+int64_t TaskManagerImpl::GetCumulativeProcessTotalNetworkUsage(
+    TaskId task_id) const {
+  return GetTaskGroupByTaskId(task_id)->cumulative_per_process_network_usage();
 }
 
 int64_t TaskManagerImpl::GetSqliteMemoryUsed(TaskId task_id) const {
   return GetTaskByTaskId(task_id)->GetSqliteMemoryUsed();
 }
 
 bool TaskManagerImpl::GetV8Memory(TaskId task_id,
                                   int64_t* allocated,
                                   int64_t* used) const {
   const Task* task = GetTaskByTaskId(task_id);
@@ skipping 193 matching lines @@
   // Invalidate the cached sorted IDs by clearing the list.
   sorted_task_ids_.clear();
 }
 
 void TaskManagerImpl::TaskUnresponsive(Task* task) {
   DCHECK(task);
   NotifyObserversOnTaskUnresponsive(task->task_id());
 }
 
 // static
-void TaskManagerImpl::OnMultipleBytesReadUI(
-    std::vector<BytesReadParam>* params) {
+void TaskManagerImpl::OnMultipleBytesTransferredUI(
+    std::vector<BytesTransferredParam>* params) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(params);
 
-  for (BytesReadParam& param : *params) {
-    if (!GetInstance()->UpdateTasksWithBytesRead(param)) {
+  for (BytesTransferredParam& param : *params) {
+    if (!GetInstance()->UpdateTasksWithBytesTransferred(param)) {
       // We can't match a task to the notification.  That might mean the
       // tab that started a download was closed, or the request may have had
       // no originating task associated with it in the first place.
       // We attribute orphaned/unaccounted activity to the Browser process.
       DCHECK(param.origin_pid || (param.child_id != -1));
 
       param.origin_pid = 0;
       param.child_id = param.route_id = -1;
-
-      GetInstance()->UpdateTasksWithBytesRead(param);
+      GetInstance()->UpdateTasksWithBytesTransferred(param);
     }
   }
 }
 
 void TaskManagerImpl::OnVideoMemoryUsageStatsUpdate(
     const gpu::VideoMemoryUsageStats& gpu_memory_stats) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   gpu_memory_stats_ = gpu_memory_stats;
 }
@@ skipping 47 matching lines @@
                                            int route_id) const {
   for (const auto& task_provider : task_providers_) {
     Task* task =
         task_provider->GetTaskOfUrlRequest(origin_pid, child_id, route_id);
     if (task)
       return task;
   }
   return nullptr;
 }
 
-bool TaskManagerImpl::UpdateTasksWithBytesRead(const BytesReadParam& param) {
+bool TaskManagerImpl::UpdateTasksWithBytesTransferred(
+    const BytesTransferredParam& param) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   Task* task =
       GetTaskByPidOrRoute(param.origin_pid, param.child_id, param.route_id);
   if (task) {
-    task->OnNetworkBytesRead(param.byte_count);
+    task->OnNetworkBytesRead(param.byte_read_count);
+    task->OnNetworkBytesSent(param.byte_sent_count);
     return true;
   }
 
   // Couldn't match the bytes to any existing task.
   return false;
 }
 
 TaskGroup* TaskManagerImpl::GetTaskGroupByTaskId(TaskId task_id) const {
   auto it = task_groups_by_task_id_.find(task_id);
   DCHECK(it != task_groups_by_task_id_.end());
@@ skipping 12 matching lines @@
         groups_itr.second->AreBackgroundCalculationsDone();
   }
   if (are_all_processes_data_ready) {
     NotifyObserversOnRefreshWithBackgroundCalculations(GetTaskIdsList());
     for (const auto& groups_itr : task_groups_by_proc_id_)
       groups_itr.second->ClearCurrentBackgroundCalculationsFlags();
   }
 }
 
 }  // namespace task_manager