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 |
+    REFRESH_TYPE_START_TIME |
+    REFRESH_TYPE_CPU_TIME |
 #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);
 }
 
 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);
 
   expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;

[afakhry, 2016/12/21 18:34:34]

Now that we have calculations done only by the |shared_sampler_| and not by the
|worker_thread_sampler_|. This means for non-Windows platforms
OnBackgroundRefreshTypeFinished() will never be called for the start and CPU
times. If someone enables these refresh types by mistake, observers will stop
receiving OnTasksRefreshedWithBackgroundCalculations() signals.

Here's a suggestion:
We can add TaskGroupSampler::GetSupportedFlags(). Then we'll have:
int64_t expected_shared_flags = 
    refresh_flags & shared_sampler_->GetSupportedFlags();
int64_t expected_non_shared_flags =
    refresh_flags & worker_thread_sampler_->GetSupportedFlags();

expected_on_bg_done_flags_ = 
    expected_shared_flags | expected_non_shared_flags;

[chengx, 2016/12/21 22:05:54]

Thanks for the suggestion. I think adding an '#if defined(OS_WIN)'for
kBackgroundRefreshTypesMask as in line 28 should also work. If using
GetSupportedFlags(), we may need to delete kBackgroundRefreshTypesMask as it is
no longer useful. Correct me please if I am wrong.

[afakhry, 2016/12/22 00:28:14]

Yes, correct. If you go with my suggestion, we'll have to remove
kBackgroundRefreshTypesMask. 

The only problem with kBackgroundRefreshTypesMask is that we have to keep it in
sync with what shared and the non-shared samplers offer on various platforms
which can get hairy and makes it easy to introduce bugs (as what was about to
happen here). So the advantage of the suggestion is that we get to keep that
knowledge in the samplers themselves and query them accordingly.

That said, I can live with kBackgroundRefreshTypesMask for now. :)

   // 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;
   for (Task* task : tasks_) {
@@ skipping 95 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