Update the task manager with the debug stub port chosen by nacl.

components/nacl/loader/nacl_listener.cc

 // Copyright 2013 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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <stdlib.h>
 
 #if defined(OS_POSIX)
@@ skipping 66 matching lines @@
   // Fall back to NaCl's default implementation.
   return -1;
 }
 
 #elif defined(OS_LINUX)
 
 int CreateMemoryObject(size_t size, int executable) {
   return content::MakeSharedMemorySegmentViaIPC(size, executable);
 }
 
+NaClListener* g_listener;

[Mark Seaborn, 2014/03/26 23:34:04]

Shouldn't this be unconditional?  Doesn't look like this will compile.

[bradn, 2014/05/05 18:46:07]

Oops. Done. Not sure why it ended up like that.

+
 #elif defined(OS_WIN)
 
-NaClListener* g_listener;
-
 // We wrap the function to convert the bool return value to an int.
 int BrokerDuplicateHandle(NaClHandle source_handle,
                           uint32_t process_id,
                           NaClHandle* target_handle,
                           uint32_t desired_access,
                           uint32_t options) {
   return content::BrokerDuplicateHandle(source_handle, process_id,
                                         target_handle, desired_access,
                                         options);
 }
 
 int AttachDebugExceptionHandler(const void* info, size_t info_size) {
   std::string info_string(reinterpret_cast<const char*>(info), info_size);
   bool result = false;
   if (!g_listener->Send(new NaClProcessMsg_AttachDebugExceptionHandler(
            info_string, &result)))
     return false;
   return result;
 }
 
 #endif
 
+void DebugStubPortSelectedHandler(uint16_t port) {
+  g_listener->Send(new NaClProcessHostMsg_DebugStubPortSelected(port));
+}
+
 // Creates the PPAPI IPC channel between the NaCl IRT and the host
 // (browser/renderer) process, and starts to listen it on the thread where
 // the given message_loop_proxy runs.
 // Also, creates and sets the corresponding NaClDesc to the given nap with
 // the FD #.
 void SetUpIPCAdapter(IPC::ChannelHandle* handle,
                      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
                      struct NaClApp* nap,
                      int nacl_fd) {
   scoped_refptr<NaClIPCAdapter> ipc_adapter(
@@ skipping 79 matching lines @@
                                io_thread_("NaCl_IOThread"),
 #if defined(OS_LINUX)
                                prereserved_sandbox_size_(0),
 #endif
 #if defined(OS_POSIX)
                                number_of_cores_(-1),  // unknown/error
 #endif
                                main_loop_(NULL) {
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
-#if defined(OS_WIN)
   DCHECK(g_listener == NULL);
   g_listener = this;
-#endif
 }
 
 NaClListener::~NaClListener() {
   NOTREACHED();
   shutdown_event_.Signal();
-#if defined(OS_WIN)
   g_listener = NULL;
-#endif
 }
 
 bool NaClListener::Send(IPC::Message* msg) {
   DCHECK(main_loop_ != NULL);
   if (base::MessageLoop::current() == main_loop_) {
     // This thread owns the channel.
     return channel_->Send(msg);
   } else {
     // This thread does not own the channel.
     return filter_->Send(msg);
@@ skipping 171 matching lines @@
 
     // Indicate that this is a PNaCl module.
     // TODO(jvoung): Plumb through something indicating that this is PNaCl
     // instead of relying on enable_dyncode_syscalls.
     args->pnacl_mode = 1;
   }
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   args->debug_stub_server_bound_socket_fd = nacl::ToNativeHandle(
       params.debug_stub_server_bound_socket);
 #endif
+  args->debug_stub_server_port_selected_handler_func =
+      DebugStubPortSelectedHandler;
 #if defined(OS_WIN)
   args->broker_duplicate_handle_func = BrokerDuplicateHandle;
   args->attach_debug_exception_handler_func = AttachDebugExceptionHandler;
 #endif
 #if defined(OS_LINUX)
   args->prereserved_sandbox_size = prereserved_sandbox_size_;
 #endif
 
 #if defined(OS_LINUX)
   if (params.uses_nonsfi_mode) {
     nacl::nonsfi::MainStart(args->imc_bootstrap_handle);
     return;
   }
 #endif
   NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }