Add process start time and CPU time columns to 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"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "chrome/browser/task_manager/sampling/shared_sampler.h"
 #include "chrome/browser/task_manager/task_manager_observer.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/ipc/common/memory_stats.h"
 
 namespace task_manager {
 
 namespace {
 
 // A mask for the refresh types that are done in the background thread.
 const int kBackgroundRefreshTypesMask =
     REFRESH_TYPE_CPU |
     REFRESH_TYPE_MEMORY |
     REFRESH_TYPE_IDLE_WAKEUPS |
+#if defined(OS_WIN)
+    REFRESH_TYPE_START_TIME |
+    REFRESH_TYPE_CPU_TIME |
+#endif  // defined(OS_WIN)
 #if defined(OS_LINUX)
     REFRESH_TYPE_FD_COUNT |
 #endif  // defined(OS_LINUX)
     REFRESH_TYPE_PRIORITY;
 
 #if defined(OS_WIN)
 // Gets the GDI and USER Handles on Windows at one shot.
 void GetWindowsHandles(base::ProcessHandle handle,
                        int64_t* out_gdi_current,
                        int64_t* out_gdi_peak,
@@ skipping 31 matching lines @@
     const scoped_refptr<SharedSampler>& shared_sampler,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_pool_runner)
     : 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),
+      start_time_(0),
+      cpu_time_(0),
       gpu_memory_(-1),
       per_process_network_usage_(-1),
 #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_(-1),
@@ skipping 19 matching lines @@
                                       weak_ptr_factory_.GetWeakPtr()),
 #endif  // defined(OS_LINUX)
                            base::Bind(&TaskGroup::OnProcessPriorityDone,
                                       weak_ptr_factory_.GetWeakPtr())));
   worker_thread_sampler_.swap(sampler);
 
   shared_sampler_->RegisterCallbacks(
       process_id_, base::Bind(&TaskGroup::OnIdleWakeupsRefreshDone,
                               weak_ptr_factory_.GetWeakPtr()),
                    base::Bind(&TaskGroup::OnPhysicalMemoryUsageRefreshDone,
+                              weak_ptr_factory_.GetWeakPtr()),
+                   base::Bind(&TaskGroup::OnStartTimeRefreshDone,
+                              weak_ptr_factory_.GetWeakPtr()),
+                   base::Bind(&TaskGroup::OnCpuTimeRefreshDone,
                               weak_ptr_factory_.GetWeakPtr()));
 }
 
 TaskGroup::~TaskGroup() {
   shared_sampler_->UnregisterCallbacks(process_id_);
 }
 
 void TaskGroup::AddTask(Task* task) {
   DCHECK(task);
   tasks_.push_back(task);
@@ skipping 118 matching lines @@
 #endif  // !defined(DISABLE_NACL)
 }
 
 void TaskGroup::OnCpuRefreshDone(double cpu_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   cpu_usage_ = cpu_usage;
   OnBackgroundRefreshTypeFinished(REFRESH_TYPE_CPU);
 }
 
+void TaskGroup::OnStartTimeRefreshDone(uint64_t start_time) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  start_time_ = start_time;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_START_TIME);
+}
+
+void TaskGroup::OnCpuTimeRefreshDone(uint64_t cpu_time) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  cpu_time_ = cpu_time;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_CPU_TIME);
+}
+
 void TaskGroup::OnPhysicalMemoryUsageRefreshDone(int64_t physical_bytes) {
 #if defined(OS_WIN)
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   memory_usage_.physical_bytes = physical_bytes;
   OnBackgroundRefreshTypeFinished(REFRESH_TYPE_PHYSICAL_MEMORY);
 #endif  // OS_WIN
 }
 
 void TaskGroup::OnMemoryUsageRefreshDone(MemoryUsageStats memory_usage) {
@@ skipping 34 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