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 482 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;
   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;
 
     case IDS_TASK_MANAGER_KEEPALIVE_COUNT_COLUMN:
       type = REFRESH_TYPE_KEEPALIVE_COUNT;
       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