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 29 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #include <fcntl.h>
 #include <io.h>
 
 #include "content/public/common/sandbox_init.h"
 #endif
 
 namespace {
+
+NaClListener* g_listener;
+
 #if defined(OS_MACOSX)
 
 // On Mac OS X, shm_open() works in the sandbox but does not give us
 // an FD that we can map as PROT_EXEC.  Rather than doing an IPC to
 // get an executable SHM region when CreateMemoryObject() is called,
 // we preallocate one on startup, since NaCl's sel_ldr only needs one
 // of them.  This saves a round trip.
 
 base::subtle::Atomic32 g_shm_fd = -1;
 
@@ skipping 20 matching lines @@
 }
 
 #elif defined(OS_LINUX)
 
 int CreateMemoryObject(size_t size, int executable) {
   return content::MakeSharedMemorySegmentViaIPC(size, executable);
 }
 
 #elif defined(OS_WIN)
 
-NaClListener* g_listener;

[Mark Seaborn, 2014/05/08 15:52:23]

This should stay conditional on OS_WIN.

[bradn, 2014/05/08 17:00:24]

Er, ok, back again...

-
 // 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) {

[Mark Seaborn, 2014/05/08 15:52:23]

Also only needed on OS_WIN.

Currently you have werrors under Clang about DebugStubPortSelectedHandler being
defined but not used.

[bradn, 2014/05/08 17:00:24]

You've flip flopped here, in the previous version you seemed to be pushing for
these existing on all platforms, but conditional seems more consistent anyhow.
Switching.

[Mark Seaborn, 2014/05/08 18:04:44]

To be fair, you sent me a change that didn't compile. :-p  So I made a very
quick suggestion without looking much at the context.

+  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 80 matching lines @@
                                uses_nonsfi_mode_(false),
 #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)

[Mark Seaborn, 2014/05/08 15:52:23]

These conditionals can stay.

[bradn, 2014/05/08 17:00:24]

Done.

   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 213 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
 #if defined(OS_WIN)
+  args->debug_stub_server_port_selected_handler_func =

[Mark Seaborn, 2014/05/08 15:52:23]

Nit: maybe put this after "args->attach_debug_exception_handler_func = ..."
since it's less important?

[bradn, 2014/05/08 17:00:24]

Done.

+      DebugStubPortSelectedHandler;
   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
 
   NaClChromeMainStartApp(nap, args);
   NOTREACHED();
 }