plumb network upload into the task manager

chrome/browser/task_manager/sampling/task_group.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_group.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 73 matching lines @@
     : process_handle_(proc_handle),
       process_id_(proc_id),
       on_background_calculations_done_(on_background_calculations_done),
       worker_thread_sampler_(nullptr),
       shared_sampler_(shared_sampler),
       expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
       current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       gpu_memory_(-1),
       memory_state_(base::MemoryState::UNKNOWN),
-      per_process_network_usage_(-1),
+      per_process_network_usage_rate_(-1),
+      cumulative_per_process_network_usage_(0),
 #if defined(OS_WIN)
       gdi_current_handles_(-1),
       gdi_peak_handles_(-1),
       user_current_handles_(-1),
       user_peak_handles_(-1),
 #endif  // defined(OS_WIN)
 #if !defined(DISABLE_NACL)
       nacl_debug_stub_port_(nacl::kGdbDebugStubPortUnknown),
 #endif  // !defined(DISABLE_NACL)
       idle_wakeups_per_second_(-1),
@@ skipping 43 matching lines @@
 void TaskGroup::RemoveTask(Task* task) {
   DCHECK(task);
   tasks_.erase(std::remove(tasks_.begin(), tasks_.end(), task), tasks_.end());
 }
 
 void TaskGroup::Refresh(const gpu::VideoMemoryUsageStats& gpu_memory_stats,
                         base::TimeDelta update_interval,
                         int64_t refresh_flags) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!empty());
-
   expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;
   // If a refresh type was recently disabled, we need to account for that too.
   current_on_bg_done_flags_ &= expected_on_bg_done_flags_;
 
   // First refresh the enabled non-expensive resources usages on the UI thread.
   // 1- Refresh all the tasks as well as the total network usage (if enabled).
   const bool network_usage_refresh_enabled =
       TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NETWORK_USAGE,
                                                     refresh_flags);
-  per_process_network_usage_ = network_usage_refresh_enabled ? 0 : -1;
+
+  per_process_network_usage_rate_ = network_usage_refresh_enabled ? 0 : -1;
+  cumulative_per_process_network_usage_ = 0;
   for (Task* task : tasks_) {
     task->Refresh(update_interval, refresh_flags);
-
-    if (network_usage_refresh_enabled && task->ReportsNetworkUsage())
-      per_process_network_usage_ += task->network_usage();
+    if (network_usage_refresh_enabled) {
+      per_process_network_usage_rate_ += task->network_usage_rate();
+      cumulative_per_process_network_usage_ += task->cumulative_network_usage();
+    }
   }
 
   // 2- Refresh GPU memory (if enabled).
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_GPU_MEMORY,
                                                     refresh_flags)) {
     RefreshGpuMemory(gpu_memory_stats);
   }
 
   // 3- Refresh Windows handles (if enabled).
 #if defined(OS_WIN)
@@ skipping 167 matching lines @@
 
 void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   current_on_bg_done_flags_ |= finished_refresh_type;
   if (AreBackgroundCalculationsDone())
     on_background_calculations_done_.Run();
 }
 
 }  // namespace task_manager