Add a task manager column that shows memory state of processes

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"
@@ skipping 45 matching lines @@
     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:
     case IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN:
     case IDS_TASK_MANAGER_PROCESS_PRIORITY_COLUMN:
+    case IDS_TASK_MANAGER_MEMORY_STATE_COLUMN:
       return true;
     default:
       return false;
   }
 }
 
 // Used to sort various column values.
 template <class T>
 int ValueCompare(T value1, T value2) {
   if (value1 == value2)
@@ skipping 27 matching lines @@
       : n_a_string_(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT)),
         zero_string_(base::ASCIIToUTF16("0")),
         backgrounded_string_(l10n_util::GetStringUTF16(
             IDS_TASK_MANAGER_BACKGROUNDED_TEXT)),
         foregrounded_string_(l10n_util::GetStringUTF16(
             IDS_TASK_MANAGER_FOREGROUNDED_TEXT)),
         asterisk_string_(base::ASCIIToUTF16("*")),
         unknown_string_(l10n_util::GetStringUTF16(
             IDS_TASK_MANAGER_UNKNOWN_VALUE_TEXT)),
         disabled_nacl_debugging_string_(l10n_util::GetStringUTF16(
-            IDS_TASK_MANAGER_DISABLED_NACL_DBG_TEXT)) {
+            IDS_TASK_MANAGER_DISABLED_NACL_DBG_TEXT)),
+        memory_state_normal_string_(l10n_util::GetStringUTF16(
+            IDS_TASK_MANAGER_MEMORY_STATE_NORMAL_TEXT)),
+        memory_state_throttled_string_(l10n_util::GetStringUTF16(
+            IDS_TASK_MANAGER_MEMORY_STATE_THROTTLED_TEXT)),
+        memory_state_suspended_string_(l10n_util::GetStringUTF16(
+            IDS_TASK_MANAGER_MEMORY_STATE_SUSPENDED_TEXT)) {
   }
 
   ~TaskManagerValuesStringifier() {}
 
   base::string16 GetCpuUsageText(double cpu_usage) {
     return base::UTF8ToUTF16(base::StringPrintf(kCpuTextFormatString,
                                                 cpu_usage));
   }
 
   base::string16 GetMemoryUsageText(int64_t memory_usage, bool has_duplicates) {
@@ skipping 12 matching lines @@
     memory_text = l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT,
                                              memory_text);
 #endif  // defined(OS_MACOSX)
 
     if (has_duplicates)
       memory_text += asterisk_string_;
 
     return memory_text;
   }
 
+  base::string16 GetMemoryStateText(base::MemoryState state) {
+    switch (state) {
+      case base::MemoryState::NORMAL:
+        return memory_state_normal_string_;
+      case base::MemoryState::THROTTLED:
+        return memory_state_throttled_string_;
+      case base::MemoryState::SUSPENDED:
+        return memory_state_suspended_string_;
+      case base::MemoryState::UNKNOWN:
+        return n_a_string_;
+    }
+    NOTREACHED();
+    return n_a_string_;
+  }
+
   base::string16 GetIdleWakeupsText(int idle_wakeups) {
     if (idle_wakeups == -1)
       return n_a_string_;
 
     return base::FormatNumber(idle_wakeups);
   }
 
   base::string16 GetNaClPortText(int nacl_port) {
     if (nacl_port == nacl::kGdbDebugStubPortUnused || nacl_port == -2)
       return n_a_string_;
@@ skipping 69 matching lines @@
   // GPU memory.
   const base::string16 asterisk_string_;
 
   // The string "Unknown".
   const base::string16 unknown_string_;
 
   // The string to show on the NaCl debug port column cells when the flag
   // #enable-nacl-debug is disabled.
   const base::string16 disabled_nacl_debugging_string_;
 
+  // Localized strings for memory states.
+  const base::string16 memory_state_normal_string_;
+  const base::string16 memory_state_throttled_string_;
+  const base::string16 memory_state_suspended_string_;
+
   DISALLOW_COPY_AND_ASSIGN(TaskManagerValuesStringifier);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // TableSortDescriptor:
 ////////////////////////////////////////////////////////////////////////////////
 
 TableSortDescriptor::TableSortDescriptor()
     : sorted_column_id(-1),
       is_ascending(false) {
@@ skipping 146 matching lines @@
           : stringifier_->foregrounded_string();
 
 #if defined(OS_LINUX)
     case IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN: {
       const int fd_count = observed_task_manager()->GetOpenFdCount(tasks_[row]);
       return fd_count >= 0 ? base::FormatNumber(fd_count)
                            : stringifier_->n_a_string();
     }
 #endif  // defined(OS_LINUX)
 
+    case IDS_TASK_MANAGER_MEMORY_STATE_COLUMN: {
+      return stringifier_->GetMemoryStateText(
+          observed_task_manager()->GetMemoryState(tasks_[row]));
+    }
+
     default:
       NOTREACHED();
       return base::string16();
   }
 }
 
 gfx::ImageSkia TaskManagerTableModel::GetIcon(int row) {
   return observed_task_manager()->GetIcon(tasks_[row]);
 }
 
 void TaskManagerTableModel::SetObserver(
     ui::TableModelObserver* observer) {
   table_model_observer_ = observer;
 }
 
 int TaskManagerTableModel::CompareValues(int row1,
                                          int row2,
                                          int column_id) {
   switch (column_id) {
     case IDS_TASK_MANAGER_TASK_COLUMN:
     case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
+    case IDS_TASK_MANAGER_MEMORY_STATE_COLUMN:
       return ui::TableModel::CompareValues(row1, row2, column_id);
 
     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]));
@@ skipping 260 matching lines @@
       break;
 
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
       type = REFRESH_TYPE_NACL;
       break;
 
     case IDS_TASK_MANAGER_PROCESS_PRIORITY_COLUMN:
       type = REFRESH_TYPE_PRIORITY;
       break;
 
+    case IDS_TASK_MANAGER_MEMORY_STATE_COLUMN:
+      type = REFRESH_TYPE_MEMORY_STATE;
+      break;
+
 #if defined(OS_LINUX)
     case IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN:
       type = REFRESH_TYPE_FD_COUNT;
       break;
 #endif  // defined(OS_LINUX)
 
     default:
       NOTREACHED();
       return;
   }
@@ skipping 120 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