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 72 matching lines @@
       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 71 matching lines @@
                                                     refresh_flags)) {
     RefreshWindowsHandles();
   }
 #endif  // defined(OS_WIN)
 
 // 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) &&
+      nacl_debug_stub_port_ == nacl::kGdbDebugStubPortUnknown &&

[Wez, 2017/01/20 03:25:28]

bradnelson: I thought of adding this, but I think for it to work we would need
NaClBrowser to return Unknown for the port number until the process checks-in,
because of async port allocation under Windows - we'd probably want to hard-wire
non-NACL process types to Unused and update the GetDebugGdbStubPort() API to
return Unknown rather than Unused. Probably not worth optimizing this, though..
:P

       !tasks_.empty()) {
     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.
@@ skipping 56 matching lines @@
 #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)
+static int GetNaClDebugStubPort(int process_id) {
+  return nacl::NaClBrowser::GetInstance()->GetProcessGdbDebugStubPort(
+      process_id);
+}
+
 void TaskGroup::RefreshNaClDebugStubPort(int child_process_unique_id) {
-  nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&nacl::NaClBrowser::GetProcessGdbDebugStubPort,
-                 base::Unretained(nacl_browser), child_process_unique_id),
+      base::Bind(&GetNaClDebugStubPort, 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);
 }
@@ skipping 67 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