NaCl repo side changes to make crash reporting more reliable.

src/trusted/reverse_service/reverse_service.cc

 /*
  * Copyright (c) 2011 The Native Client 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 <string.h>
 
 #include "native_client/src/trusted/reverse_service/reverse_service.h"
 
@@ skipping 34 matching lines @@
                 NaClSrpcArg** in_args,
                 NaClSrpcArg** out_args,
                 NaClSrpcClosure* done) {
   nacl::ReverseService* service = reinterpret_cast<nacl::ReverseService*>(
       rpc->channel->server_instance_data);
   NaClSrpcClosureRunner on_return(done);
 
   UNREFERENCED_PARAMETER(in_args);
 
   NaClLog(4, "Entered AddChannel\n");
-  out_args[0]->u.bval = service->Start();
+  out_args[0]->u.bval = service->Start(false);
   NaClLog(4, "Leaving AddChannel\n");
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void RevLog(NaClSrpcRpc* rpc,
             NaClSrpcArg** in_args,
             NaClSrpcArg** out_args,
             NaClSrpcClosure* done) {
   nacl::ReverseService* service = reinterpret_cast<nacl::ReverseService*>(
       rpc->channel->server_instance_data);
@@ skipping 329 matching lines @@
 
 ReverseService::~ReverseService() {
   if (thread_count_ != 0) {
     NaClLog(LOG_FATAL, "ReverseService dtor when thread count is nonzero\n");
   }
   NaClCondVarDtor(&cv_);
   NaClMutexDtor(&mu_);
 }
 
 
-bool ReverseService::Start() {
+static void RevServiceCbBinder(void *state,
+                               int  server_loop_ret) {
+  ReverseService *obj = reinterpret_cast<ReverseService *>(state);
+
+  UNREFERENCED_PARAMETER(server_loop_ret);
+  obj->reverse_interface()->ReportCrash();
+}
+
+
+bool ReverseService::Start(bool crash_report) {
   NaClLog(4, "Entered ReverseService::Start\n");
-  return service_socket_->StartService(reinterpret_cast<void*>(this));
+  if (crash_report) {
+    return service_socket_->StartServiceCb(RevServiceCbBinder,
+                                           reinterpret_cast<void*>(this));
+  } else {
+    return service_socket_->StartServiceCb(NULL,
+                                           reinterpret_cast<void*>(this));
+  }
 }
 
 void ReverseService::WaitForServiceThreadsToExit() {
   NaClLog(4, "ReverseService::WaitForServiceThreadsToExit\n");
   NaClXMutexLock(&mu_);
   while (0 != thread_count_) {
     NaClXCondVarWait(&cv_, &mu_);
     NaClLog(5, "ReverseService::WaitForServiceThreadsToExit: woke up\n");
   }
   NaClXMutexUnlock(&mu_);
@@ skipping 18 matching lines @@
             ("ReverseService::DecrThreadCount:"
              " Decrementing thread count when count is zero\n"));
   }
   if (0 == --thread_count_) {
     NaClXCondVarBroadcast(&cv_);
   }
   NaClXMutexUnlock(&mu_);
 }
 
 }  // namespace nacl