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 60 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) {
+    if (state == base::MemoryState::UNKNOWN)
+      return n_a_string_;
+    // TODO(bashi): i18n.

[afakhry, 2017/01/05 00:57:30]

Nit: This TODO is very vague. Can you please explain what exactly that needs to
be done?

[bashi, 2017/01/05 01:05:52]

Done.

[afakhry, 2017/01/05 01:27:10]

In this case it's quite simple to do here. Consider what we did for the process
priority. Take a look at the TaskManagerValuesStringifier constructor and the
way we preload the localized backgrounded/foregrounded values.

[bashi, 2017/01/05 02:18:22]

Thanks for the suggestion. The MemoryState enums aren't stabilized yet (we may
add/remove states) and I thought it would be better to localize them later. But
on second thought I think we should localize them anyway. Done.

[afakhry, 2017/01/05 17:00:20]

Perfect, thanks!

+    return base::UTF8ToUTF16(base::MemoryStateToString(state));
+  }
+
   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 235 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