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

chrome/browser/task_manager/sampling/task_group.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/task_manager/sampling/task_group.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 
 // A mask for the refresh types that are done in the background thread.
 const int kBackgroundRefreshTypesMask =
     REFRESH_TYPE_CPU | REFRESH_TYPE_MEMORY | REFRESH_TYPE_IDLE_WAKEUPS |
 #if defined(OS_WIN)
     REFRESH_TYPE_START_TIME | REFRESH_TYPE_CPU_TIME |
 #endif  // defined(OS_WIN)
 #if defined(OS_LINUX)
     REFRESH_TYPE_FD_COUNT |
 #endif  // defined(OS_LINUX)
+#if !defined(DISABLE_NACL)
+    REFRESH_TYPE_NACL |
+#endif  // !defined(DISABLE_NACL)
     REFRESH_TYPE_PRIORITY;
 
 #if defined(OS_WIN)
 // Gets the GDI and USER Handles on Windows at one shot.
 void GetWindowsHandles(base::ProcessHandle handle,
                        int64_t* out_gdi_current,
                        int64_t* out_gdi_peak,
                        int64_t* out_user_current,
                        int64_t* out_user_peak) {
   *out_gdi_current = 0;
@@ skipping 12 matching lines @@
         GetGuiResources(process_with_query_rights, GR_GDIOBJECTS_PEAK));
     *out_user_current = static_cast<int64_t>(
         GetGuiResources(process_with_query_rights, GR_USEROBJECTS));
     *out_user_peak = static_cast<int64_t>(
         GetGuiResources(process_with_query_rights, GR_USEROBJECTS_PEAK));
     CloseHandle(process_with_query_rights);
   }
 }
 #endif  // defined(OS_WIN)
 
+#if !defined(DISABLE_NACL)
+int GetNaClDebugStubPortOnIoThread(int process_id) {
+  return nacl::NaClBrowser::GetInstance()->GetProcessGdbDebugStubPort(
+      process_id);
+}
+#endif  // !defined(DISABLE_NACL)
+
 }  // namespace
 
 TaskGroup::TaskGroup(
     base::ProcessHandle proc_handle,
     base::ProcessId proc_id,
     const base::Closure& on_background_calculations_done,
     const scoped_refptr<SharedSampler>& shared_sampler,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_pool_runner)
     : process_handle_(proc_handle),
       process_id_(proc_id),
       on_background_calculations_done_(on_background_calculations_done),
       worker_thread_sampler_(nullptr),
       shared_sampler_(shared_sampler),
       expected_on_bg_done_flags_(kBackgroundRefreshTypesMask),
       current_on_bg_done_flags_(0),
       cpu_usage_(0.0),
       gpu_memory_(-1),
       memory_state_(base::MemoryState::UNKNOWN),
       per_process_network_usage_(-1),
 #if defined(OS_WIN)
       gdi_current_handles_(-1),
       gdi_peak_handles_(-1),
       user_current_handles_(-1),
       user_peak_handles_(-1),
 #endif  // defined(OS_WIN)
 #if !defined(DISABLE_NACL)
-      nacl_debug_stub_port_(-1),
+      nacl_debug_stub_port_(nacl::kGdbDebugStubPortUnknown),
 #endif  // !defined(DISABLE_NACL)
       idle_wakeups_per_second_(-1),
 #if defined(OS_LINUX)
       open_fd_count_(-1),
 #endif  // defined(OS_LINUX)
       gpu_memory_has_duplicates_(false),
       is_backgrounded_(false),
       weak_ptr_factory_(this) {
   scoped_refptr<TaskGroupSampler> sampler(
       new TaskGroupSampler(base::Process::Open(proc_id),
@@ skipping 34 matching lines @@
 
 void TaskGroup::RemoveTask(Task* task) {
   DCHECK(task);
   tasks_.erase(std::remove(tasks_.begin(), tasks_.end(), task), tasks_.end());
 }
 
 void TaskGroup::Refresh(const gpu::VideoMemoryUsageStats& gpu_memory_stats,
                         base::TimeDelta update_interval,
                         int64_t refresh_flags) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(!empty());
 
   expected_on_bg_done_flags_ = refresh_flags & kBackgroundRefreshTypesMask;
   // If a refresh type was recently disabled, we need to account for that too.
   current_on_bg_done_flags_ &= expected_on_bg_done_flags_;
 
   // First refresh the enabled non-expensive resources usages on the UI thread.
   // 1- Refresh all the tasks as well as the total network usage (if enabled).
   const bool network_usage_refresh_enabled =
       TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NETWORK_USAGE,
                                                     refresh_flags);
@@ skipping 12 matching lines @@
   }
 
   // 3- Refresh Windows handles (if enabled).
 #if defined(OS_WIN)
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_HANDLES,
                                                     refresh_flags)) {
     RefreshWindowsHandles();
   }
 #endif  // defined(OS_WIN)
 
-  // 4- Refresh the NACL debug stub port (if enabled).
+// 4- Refresh the NACL debug stub port (if enabled). This calls out to
+//    NaClBrowser on the browser's IO thread, completing asynchronously.
 #if !defined(DISABLE_NACL)
   if (TaskManagerObserver::IsResourceRefreshEnabled(REFRESH_TYPE_NACL,
-                                                    refresh_flags) &&
-      !tasks_.empty()) {
+                                                    refresh_flags)) {
     RefreshNaClDebugStubPort(tasks_[0]->GetChildProcessUniqueID());
   }
 #endif  // !defined(DISABLE_NACL)
 
   int64_t shared_refresh_flags =
       refresh_flags & shared_sampler_->GetSupportedFlags();
 
   // 5- Refresh resources via SharedSampler if the current platform
   // implementation supports that. The actual work is done on the worker thread.
   // At the moment this is supported only on OS_WIN.
@@ skipping 54 matching lines @@
 void TaskGroup::RefreshWindowsHandles() {
 #if defined(OS_WIN)
   GetWindowsHandles(process_handle_,
                     &gdi_current_handles_,
                     &gdi_peak_handles_,
                     &user_current_handles_,
                     &user_peak_handles_);
 #endif  // defined(OS_WIN)
 }
 
+#if !defined(DISABLE_NACL)
 void TaskGroup::RefreshNaClDebugStubPort(int child_process_unique_id) {
-#if !defined(DISABLE_NACL)
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
-  nacl_debug_stub_port_ =
-      nacl_browser->GetProcessGdbDebugStubPort(child_process_unique_id);
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&GetNaClDebugStubPortOnIoThread, child_process_unique_id),
+      base::Bind(&TaskGroup::OnRefreshNaClDebugStubPortDone,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void TaskGroup::OnRefreshNaClDebugStubPortDone(int nacl_debug_stub_port) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  nacl_debug_stub_port_ = nacl_debug_stub_port;
+  OnBackgroundRefreshTypeFinished(REFRESH_TYPE_NACL);
+}
 #endif  // !defined(DISABLE_NACL)
-}
 
 void TaskGroup::OnCpuRefreshDone(double cpu_usage) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   cpu_usage_ = cpu_usage;
   OnBackgroundRefreshTypeFinished(REFRESH_TYPE_CPU);
 }
 
 void TaskGroup::OnStartTimeRefreshDone(base::Time start_time) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 56 matching lines @@
 
 void TaskGroup::OnBackgroundRefreshTypeFinished(int64_t finished_refresh_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   current_on_bg_done_flags_ |= finished_refresh_type;
   if (AreBackgroundCalculationsDone())
     on_background_calculations_done_.Run();
 }
 
 }  // namespace task_manager