Fix various TaskManager bugs and add new enhancements

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 "base/command_line.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/prefs/scoped_user_pref_update.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 "chrome/browser/browser_process.h"
 #include "chrome/browser/task_management/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 "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_management {
 
 namespace {
 
@@ skipping 10 matching lines @@
 #endif  // defined(OS_MACOSX)
 
 // 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_CPU_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:
       return true;
     default:
       return false;
   }
 }
 
 // Used to sort various column values.
 template <class T>
 int ValueCompare(T value1, T value2) {
   if (value1 == value2)
@@ skipping 12 matching lines @@
 
 // A class to stringify the task manager's values into string16s and to
 // cache the common strings that will be reused many times like "N/A" and so on.
 class TaskManagerValuesStringifier {
  public:
   TaskManagerValuesStringifier()
       : n_a_string_(l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT)),
         zero_string_(base::ASCIIToUTF16("0")),
         asterisk_string_(base::ASCIIToUTF16("*")),
         unknown_string_(l10n_util::GetStringUTF16(
-            IDS_TASK_MANAGER_UNKNOWN_VALUE_TEXT)) {
+            IDS_TASK_MANAGER_UNKNOWN_VALUE_TEXT)),
+        disabled_nacl_debugging_string_(l10n_util::GetStringUTF16(
+            IDS_TASK_MANAGER_DISABLED_NACL_DBG_TEXT)) {
   }
 
   ~TaskManagerValuesStringifier() {}
 
   base::string16 GetCpuUsageText(double cpu_usage) {
     return base::UTF8ToUTF16(base::StringPrintf(kCpuTextFormatString,
                                                 cpu_usage));
   }
 
   base::string16 GetMemoryUsageText(int64 memory_usage, bool has_duplicates) {
@@ skipping 20 matching lines @@
   }
 
   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)
+    if (nacl_port == nacl::kGdbDebugStubPortUnused || nacl_port == -2)
       return n_a_string_;
 
     if (nacl_port == nacl::kGdbDebugStubPortUnknown)
       return unknown_string_;
 
     return base::IntToString16(nacl_port);
   }
 
   base::string16 GetWindowsHandlesText(int64 current, int64 peak) {
     return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_HANDLES_CELL_TEXT,
@@ skipping 26 matching lines @@
 
   base::string16 GetWebCacheStatText(
       const blink::WebCache::ResourceTypeStat& stat) {
     return FormatAllocatedAndUsedMemory(stat.size, stat.liveSize);
   }
 
   const base::string16& n_a_string() const { return n_a_string_; }
   const base::string16& zero_string() const { return zero_string_; }
   const base::string16& asterisk_string() const { return asterisk_string_; }
   const base::string16& unknown_string() const { return unknown_string_; }
+  const base::string16& disabled_nacl_debugging_string() const {
+    return disabled_nacl_debugging_string_;
+  }
 
  private:
   // The localized string "N/A".
   const base::string16 n_a_string_;
 
   // The value 0 as a string "0".
   const base::string16 zero_string_;
 
   // The string "*" that is used to show that there exists duplicates in the
   // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(TaskManagerValuesStringifier);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // TableSortDescriptor:
 ////////////////////////////////////////////////////////////////////////////////
 
 TableSortDescriptor::TableSortDescriptor()
     : sorted_column_id(-1),
       is_ascending(false) {
 }
 
 TableSortDescriptor::TableSortDescriptor(int col_id, bool ascending)
     : sorted_column_id(col_id),
       is_ascending(ascending) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTableModel:
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerTableModel::TaskManagerTableModel(int64_t refresh_flags,
                                              TableViewDelegate* delegate)
     : TaskManagerObserver(base::TimeDelta::FromMilliseconds(kRefreshTimeMS),
                           refresh_flags),
       table_view_delegate_(delegate),
       columns_settings_(new base::DictionaryValue),
       table_model_observer_(nullptr),
-      stringifier_(new TaskManagerValuesStringifier) {
+      stringifier_(new TaskManagerValuesStringifier),
+#if !defined(DISABLE_NACL)
+      is_nacl_debugging_flag_enabled_(base::CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kEnableNaClDebug)) {
+#else
+      is_nacl_debugging_flag_enabled_(false) {
+#endif  // !defined(DISABLE_NACL)
   DCHECK(delegate);
 }
 
 TaskManagerTableModel::~TaskManagerTableModel() {
 }
 
 int TaskManagerTableModel::RowCount() {
   return static_cast<int>(tasks_.size());
 }
 
 base::string16 TaskManagerTableModel::GetText(int row, int column) {
   if (IsSharedByGroup(column) && !IsTaskFirstInGroup(row))
     return base::string16();
 
   switch (column) {
     case IDS_TASK_MANAGER_TASK_COLUMN:
       return observed_task_manager()->GetTitle(tasks_[row]);
 
     case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
       return observed_task_manager()->GetProfileName(tasks_[row]);
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       return stringifier_->GetNetworkUsageText(
-          observed_task_manager()->GetNetworkUsage(tasks_[row]));
+          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_PRIVATE_MEM_COLUMN:
       return stringifier_->GetMemoryUsageText(
           observed_task_manager()->GetPrivateMemoryUsage(tasks_[row]), false);
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
@@ skipping 62 matching lines @@
       if (observed_task_manager()->GetV8Memory(tasks_[row],
                                                &v8_allocated,
                                                &v8_used)) {
         return stringifier_->FormatAllocatedAndUsedMemory(v8_allocated,
                                                           v8_used);
       }
       return stringifier_->n_a_string();
     }
 
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
+      if (!is_nacl_debugging_flag_enabled_)
+        return stringifier_->disabled_nacl_debugging_string();
+
       return stringifier_->GetNaClPortText(
           observed_task_manager()->GetNaClDebugStubPort(tasks_[row]));
 
     default:
       NOTREACHED();
       return base::string16();
   }
 }
 
 gfx::ImageSkia TaskManagerTableModel::GetIcon(int row) {
@@ skipping 374 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_management