Add process start time and CPU time columns to task manager

chrome/browser/ui/task_manager/task_manager_table_model.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/ui/task_manager/task_manager_table_model.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
+#include "base/i18n/time_formatting.h"
 #include "base/macros.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/task_manager/task_manager_interface.h"
 #include "chrome/browser/ui/task_manager/task_manager_columns.h"
 #include "chrome/common/pref_names.h"
@@ skipping 22 matching lines @@
 
 // The columns that are shared by a group will show the value of the column
 // only once per group.
 bool IsSharedByGroup(int column_id) {
   switch (column_id) {
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
     case IDS_TASK_MANAGER_SWAPPED_MEM_COLUMN:
     case IDS_TASK_MANAGER_CPU_COLUMN:
+    case IDS_TASK_MANAGER_START_TIME_COLUMN:
+    case IDS_TASK_MANAGER_CPU_TIME_COLUMN:
     case IDS_TASK_MANAGER_NET_COLUMN:
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
     case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
     case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN:
     case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
     case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
@@ skipping 49 matching lines @@
             IDS_TASK_MANAGER_DISABLED_NACL_DBG_TEXT)) {
   }
 
   ~TaskManagerValuesStringifier() {}
 
   base::string16 GetCpuUsageText(double cpu_usage) {
     return base::UTF8ToUTF16(base::StringPrintf(kCpuTextFormatString,
                                                 cpu_usage));
   }
 
+  base::string16 GetStartTimeText(base::Time start_time) {
+    if (start_time.is_null())
+      return n_a_string_;
+
+    return base::TimeFormatShortDateAndTime(start_time);
+  }
+
+  base::string16 GetCpuTimeText(base::TimeDelta cpu_time) {
+    if (cpu_time.is_zero())
+      return n_a_string_;
+
+    return base::TimeDurationFormatWithSeconds(cpu_time,
+                                               base::DURATION_WIDTH_NARROW);

[stanisc, 2016/12/21 19:17:52]

Why not DURATION_WIDTH_NUMERIC?

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

There is a bug here with DURATION_WIDTH_NUMERIC. It applies the mod operation on
hour value by 24, so the hour can never be larger than 24. I have filed a bug
(id = 675791) on this. I have had a look and it turns out the fix is fairly
complicated. So I would not the NUMERIC format for now.   

+  }
+
   base::string16 GetMemoryUsageText(int64_t memory_usage, bool has_duplicates) {
     if (memory_usage == -1)
       return n_a_string_;
 
 #if defined(OS_MACOSX)
     // System expectation is to show "100 kB", "200 MB", etc.
     // TODO(thakis): [This TODO has been taken as is from the old task manager]:
     // Switch to metric units (as opposed to powers of two).
     base::string16 memory_text = ui::FormatBytes(memory_usage);
 #else
@@ skipping 158 matching lines @@
       return observed_task_manager()->GetProfileName(tasks_[row]);
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       return stringifier_->GetNetworkUsageText(
           observed_task_manager()->GetProcessTotalNetworkUsage(tasks_[row]));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:
       return stringifier_->GetCpuUsageText(
           observed_task_manager()->GetCpuUsage(tasks_[row]));
 
+    case IDS_TASK_MANAGER_CPU_TIME_COLUMN:
+      return stringifier_->GetCpuTimeText(
+          observed_task_manager()->GetCpuTime(tasks_[row]));
+
+    case IDS_TASK_MANAGER_START_TIME_COLUMN:
+      return stringifier_->GetStartTimeText(
+          observed_task_manager()->GetStartTime(tasks_[row]));
+
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
       return stringifier_->GetMemoryUsageText(
           observed_task_manager()->GetPrivateMemoryUsage(tasks_[row]), false);
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
       return stringifier_->GetMemoryUsageText(
           observed_task_manager()->GetSharedMemoryUsage(tasks_[row]), false);
 
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
       return stringifier_->GetMemoryUsageText(
@@ skipping 112 matching lines @@
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       return ValueCompare(
           observed_task_manager()->GetNetworkUsage(tasks_[row1]),
           observed_task_manager()->GetNetworkUsage(tasks_[row2]));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:
       return ValueCompare(observed_task_manager()->GetCpuUsage(tasks_[row1]),
                           observed_task_manager()->GetCpuUsage(tasks_[row2]));
 
+    case IDS_TASK_MANAGER_CPU_TIME_COLUMN:
+      return ValueCompare(observed_task_manager()->GetCpuTime(tasks_[row1]),
+                          observed_task_manager()->GetCpuTime(tasks_[row2]));
+
+    case IDS_TASK_MANAGER_START_TIME_COLUMN:
+      return ValueCompare(observed_task_manager()->GetStartTime(tasks_[row1]),
+                          observed_task_manager()->GetStartTime(tasks_[row2]));
+
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
       return ValueCompare(
           observed_task_manager()->GetPrivateMemoryUsage(tasks_[row1]),
           observed_task_manager()->GetPrivateMemoryUsage(tasks_[row2]));
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
       return ValueCompare(
           observed_task_manager()->GetSharedMemoryUsage(tasks_[row1]),
           observed_task_manager()->GetSharedMemoryUsage(tasks_[row2]));
 
@@ skipping 182 matching lines @@
       return;  // The data in these columns do not change.
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       type = REFRESH_TYPE_NETWORK_USAGE;
       break;
 
     case IDS_TASK_MANAGER_CPU_COLUMN:
       type = REFRESH_TYPE_CPU;
       break;
 
+    case IDS_TASK_MANAGER_START_TIME_COLUMN:
+      type = REFRESH_TYPE_START_TIME;
+      break;
+
+    case IDS_TASK_MANAGER_CPU_TIME_COLUMN:
+      type = REFRESH_TYPE_CPU_TIME;
+      break;
+
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:
       type = REFRESH_TYPE_PHYSICAL_MEMORY;
       break;
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
     case IDS_TASK_MANAGER_SWAPPED_MEM_COLUMN:
       type = REFRESH_TYPE_MEMORY_DETAILS;
       if (table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN) ||
@@ skipping 187 matching lines @@
 
 bool TaskManagerTableModel::IsTaskFirstInGroup(int row_index) const {
   if (row_index == 0)
     return true;
 
   return observed_task_manager()->GetProcessId(tasks_[row_index - 1]) !=
       observed_task_manager()->GetProcessId(tasks_[row_index]);
 }
 
 }  // namespace task_manager