Query NaCl processes' GDB debug port on the correct thread.

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 173 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 || nacl_port == -2)
+    // Only called if NaCl debug stub ports are enabled.
+
+    if (nacl_port == nacl::kGdbDebugStubPortUnused)
       return n_a_string_;
 
     if (nacl_port == nacl::kGdbDebugStubPortUnknown)
       return unknown_string_;
 
     return base::IntToString16(nacl_port);
   }
 
   base::string16 GetWindowsHandlesText(int64_t current, int64_t peak) {
     return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_HANDLES_CELL_TEXT,
@@ skipping 471 matching lines @@
 
 void TaskManagerTableModel::ActivateTask(int row_index) {
   observed_task_manager()->ActivateTask(tasks_[row_index]);
 }
 
 void TaskManagerTableModel::KillTask(int row_index) {
   observed_task_manager()->KillTask(tasks_[row_index]);
 }
 
 void TaskManagerTableModel::UpdateRefreshTypes(int column_id, bool visibility) {
-  bool new_visibility = visibility;
+  bool needs_refresh = visibility;

[Wez, 2017/01/23 19:21:02]

I update this method not to bother enabling NaCl refresh if it is disabled, even
if the column is displayed. Also renamed this variable since it appears to refer
to whether or not the item should be refreshed, not whether it's visible.

Is the TaskManagerTableModel unit-tested anywhere, or is that not feasible due
to dependencies?

[afakhry, 2017/02/09 01:26:59]

Check out the users of c/b/task_manager/task_manager_tester.cc it exposes the
APIs of the TaskManagerTableModel to many browser_tests.

It is not unit tested in isolation.

[Wez, 2017/02/10 02:51:56]

Acknowledged.

   RefreshType type = REFRESH_TYPE_NONE;
   switch (column_id) {
     case IDS_TASK_MANAGER_PROFILE_NAME_COLUMN:
     case IDS_TASK_MANAGER_TASK_COLUMN:
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       return;  // The data in these columns do not change.
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       type = REFRESH_TYPE_NETWORK_USAGE;
       break;
@@ skipping 17 matching lines @@
     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) ||
           table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_SHARED_MEM_COLUMN) ||
           table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_SWAPPED_MEM_COLUMN)) {
-        new_visibility = true;
+        needs_refresh = true;
       }
       break;
 
     case IDS_TASK_MANAGER_GDI_HANDLES_COLUMN:
     case IDS_TASK_MANAGER_USER_HANDLES_COLUMN:
       type = REFRESH_TYPE_HANDLES;
       if (table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_GDI_HANDLES_COLUMN) ||
           table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_USER_HANDLES_COLUMN)) {
-        new_visibility = true;
+        needs_refresh = true;
       }
       break;
 
     case IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN:
       type = REFRESH_TYPE_IDLE_WAKEUPS;
       break;
 
     case IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN:
     case IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN:
       type = REFRESH_TYPE_WEBCACHE_STATS;
       if (table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN) ||
           table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN) ||
           table_view_delegate_->IsColumnVisible(
               IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN)) {
-        new_visibility = true;
+        needs_refresh = true;
       }
       break;
 
     case IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN:
       type = REFRESH_TYPE_GPU_MEMORY;
       break;
 
     case IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN:
       type = REFRESH_TYPE_SQLITE_MEMORY;
       break;
 
     case IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN:
       type = REFRESH_TYPE_V8_MEMORY;
       break;
 
     case IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN:
       type = REFRESH_TYPE_NACL;
+      needs_refresh = needs_refresh && is_nacl_debugging_flag_enabled_;
       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;
   }
 
-  if (new_visibility)
+  if (needs_refresh)
     AddRefreshType(type);
   else
     RemoveRefreshType(type);
 }
 
 bool TaskManagerTableModel::IsTaskKillable(int row_index) const {
   return observed_task_manager()->IsTaskKillable(tasks_[row_index]);
 }
 
 void TaskManagerTableModel::RetrieveSavedColumnsSettingsAndUpdateTable() {
@@ skipping 108 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