Remove knowledge of nacl from content.

chrome/browser/task_manager/task_manager.cc

 // Copyright (c) 2012 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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/task_manager/guest_information.h"
 #include "chrome/browser/task_manager/panel_information.h"
 #include "chrome/browser/task_manager/printing_information.h"
 #include "chrome/browser/task_manager/resource_provider.h"
 #include "chrome/browser/task_manager/tab_contents_information.h"
 #include "chrome/browser/task_manager/web_contents_resource_provider.h"
 #include "chrome/browser/task_manager/worker_resource_provider.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "components/nacl/browser/nacl_browser.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/browser/extension_system.h"
 #include "grit/generated_resources.h"
 #include "grit/ui_resources.h"
@@ skipping 140 matching lines @@
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE, base::Bind(
               &TaskManagerModelGpuDataManagerObserver::
                   NotifyVideoMemoryUsageStats,
               video_memory_usage_stats));
     }
   }
 };
 
 TaskManagerModel::PerResourceValues::PerResourceValues()
-    : is_nacl_debug_stub_port_valid(false),
-      nacl_debug_stub_port(0),
-      is_title_valid(false),
+    : is_title_valid(false),
       is_profile_name_valid(false),
       network_usage(0),
       is_process_id_valid(false),
       process_id(0),
       is_goats_teleported_valid(false),
       goats_teleported(0),
       is_webcore_stats_valid(false),
       is_fps_valid(false),
       fps(0),
       is_sqlite_memory_bytes_valid(false),
@@ skipping 15 matching lines @@
       is_physical_memory_valid(false),
       physical_memory(0),
       is_video_memory_valid(false),
       video_memory(0),
       video_memory_has_duplicates(false),
       is_gdi_handles_valid(false),
       gdi_handles(0),
       gdi_handles_peak(0),
       is_user_handles_valid(0),
       user_handles(0),
-      user_handles_peak(0) {}
+      user_handles_peak(0),
+      is_nacl_debug_stub_port_valid(false),
+      nacl_debug_stub_port(0) {}
 
 TaskManagerModel::PerProcessValues::~PerProcessValues() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : pending_video_memory_usage_stats_update_(false),
       update_requests_(0),
@@ skipping 42 matching lines @@
 
 int TaskManagerModel::ResourceCount() const {
   return resources_.size();
 }
 
 int TaskManagerModel::GroupCount() const {
   return group_map_.size();
 }
 
 int TaskManagerModel::GetNaClDebugStubPort(int index) const {
-  PerResourceValues& values(GetPerResourceValues(index));
+  base::ProcessHandle handle = GetResource(index)->GetProcess();
+  PerProcessValues& values(per_process_cache_[handle]);
   if (!values.is_nacl_debug_stub_port_valid) {
-    values.is_nacl_debug_stub_port_valid = true;
-    values.nacl_debug_stub_port = GetResource(index)->GetNaClDebugStubPort();
+    return nacl::kGdbDebugStubPortUnknown;
   }
   return values.nacl_debug_stub_port;
 }
 
 int64 TaskManagerModel::GetNetworkUsage(int index) const {
   return GetNetworkUsage(GetResource(index));
 }
 
 double TaskManagerModel::GetCPUUsage(int index) const {
   return GetCPUUsage(GetResource(index));
@@ skipping 101 matching lines @@
   PerResourceValues& values(GetPerResourceValues(index));
   if (!values.is_profile_name_valid) {
     values.is_profile_name_valid = true;
     values.profile_name = GetResource(index)->GetProfileName();
   }
   return values.profile_name;
 }
 
 base::string16 TaskManagerModel::GetResourceNaClDebugStubPort(int index) const {
   int port = GetNaClDebugStubPort(index);
-  if (port == 0) {
+  if (port == nacl::kGdbDebugStubPortUnknown) {
+    return base::ASCIIToUTF16("Unknown");
+  } else if (port == nacl::kGdbDebugStubPortUnused) {
     return base::ASCIIToUTF16("N/A");
   } else {
     return base::IntToString16(port);
   }
 }
 
 base::string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
   int64 net_usage = GetNetworkUsage(index);
   if (net_usage == -1)
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
@@ skipping 741 matching lines @@
   // Notify the table that the contents have changed for it to redraw.
   FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_, OnModelChanged());
 }
 
 void TaskManagerModel::Refresh() {
   goat_salt_ = base::RandUint64();
 
   per_resource_cache_.clear();
   per_process_cache_.clear();
 
-  // Compute the CPU usage values.
+#if !defined(DISABLE_NACL)
+  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
+#endif  // !defined(DISABLE_NACL)
+
+  // Compute the CPU usage values and check if NaCl GDB debug stub port is
+  // known.
   // Note that we compute the CPU usage for all resources (instead of doing it
   // lazily) as process_util::GetCPUUsage() returns the CPU usage since the last
   // time it was called, and not calling it everytime would skew the value the
   // next time it is retrieved (as it would be for more than 1 cycle).
   // The same is true for idle wakeups.
   for (ResourceList::iterator iter = resources_.begin();
        iter != resources_.end(); ++iter) {
     base::ProcessHandle process = (*iter)->GetProcess();
     PerProcessValues& values(per_process_cache_[process]);
+#if !defined(DISABLE_NACL)
+    // Debug stub port doesn't change once known.
+    if (!values.is_nacl_debug_stub_port_valid) {
+      values.nacl_debug_stub_port = nacl_browser->GetProcessGdbDebugStubPort(
+          (*iter)->GetUniqueChildProcessId());
+      if (values.nacl_debug_stub_port != nacl::kGdbDebugStubPortUnknown) {
+        values.is_nacl_debug_stub_port_valid = true;
+      }
+    }
+#endif  // !defined(DISABLE_NACL)
     if (values.is_cpu_usage_valid && values.is_idle_wakeups_valid)
       continue;
     MetricsMap::iterator metrics_iter = metrics_map_.find(process);
     DCHECK(metrics_iter != metrics_map_.end());
     if (!values.is_cpu_usage_valid) {
       values.is_cpu_usage_valid = true;
       values.cpu_usage = metrics_iter->second->GetCPUUsage();
     }
 #if defined(OS_MACOSX)
     // TODO: Implement GetIdleWakeupsPerSecond() on other platforms,
@@ skipping 379 matching lines @@
   params.host_desktop_type = desktop_type;
   chrome::Navigate(&params);
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }