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"
 #include "base/i18n/rtl.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"
 #include "chrome/grit/generated_resources.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "content/public/common/content_features.h"
 #include "content/public/common/result_codes.h"
 #include "third_party/WebKit/public/web/WebCache.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/table_model_observer.h"
 #include "ui/base/text/bytes_formatting.h"
 
 namespace task_manager {
 
 namespace {
 
@@ skipping 19 matching lines @@
     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:
     case IDS_TASK_MANAGER_OPEN_FD_COUNT_COLUMN:
     case IDS_TASK_MANAGER_PROCESS_PRIORITY_COLUMN:

[afakhry, 2017/01/03 18:53:16]

Since the Memory State is a per-process value, please add
IDS_TASK_MANAGER_MEMORY_STATE_COLUMN here.

[bashi, 2017/01/05 00:51:49]

Done.

       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 (base::FeatureList::IsEnabled(features::kMemoryCoordinator)) {

[afakhry, 2017/01/03 18:53:17]

I noticed we do this test twice; here and in TaskGroup::Refresh(), so if the
feature is disabled, the value will be unknown. Can we just use N/A for
"unknown" and avoid repeating this test? Or does "unknown" convey something
important if the feature is enabled?

[bashi, 2017/01/05 00:51:49]

Done.

+      // TODO(bashi): i18n.
+      return base::UTF8ToUTF16(base::MemoryStateToString(state));
+    }
+    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 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:

[afakhry, 2017/01/03 18:53:17]

Please add IDS_TASK_MANAGER_MEMORY_STATE_COLUMN so that we can sort the tasks by
the Memory State column, and make sure that it's working.

[bashi, 2017/01/05 00:51:49]

Done.

       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