Adds some code to help isolate where crash is happening

mojo/message_pump/message_pump_mojo.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 "mojo/message_pump/message_pump_mojo.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/alias.h"
@@ skipping 20 matching lines @@
   const int64_t delta = (time_ticks - now).InMicroseconds();
   return delta < 0 ? static_cast<MojoDeadline>(0) :
                      static_cast<MojoDeadline>(delta);
 }
 
 }  // namespace
 
 // State needed for one iteration of WaitMany. The first handle and flags
 // corresponds to that of the control pipe.
 struct MessagePumpMojo::WaitState {
+  // This uses individual vectors for better use with WaitMany().
   std::vector<Handle> handles;
   std::vector<MojoHandleSignals> wait_signals;
+  std::vector<int> locations;
 };
 
 struct MessagePumpMojo::RunState {
   RunState() : should_quit(false) {
     CreateMessagePipe(NULL, &read_handle, &write_handle);
   }
 
   base::TimeTicks delayed_work_time;
 
   // Used to wake up WaitForWork().
@@ skipping 17 matching lines @@
 // static
 scoped_ptr<base::MessagePump> MessagePumpMojo::Create() {
   return scoped_ptr<MessagePump>(new MessagePumpMojo());
 }
 
 // static
 MessagePumpMojo* MessagePumpMojo::current() {
   return g_tls_current_pump.Pointer()->Get();
 }
 
-void MessagePumpMojo::AddHandler(MessagePumpMojoHandler* handler,
+void MessagePumpMojo::AddHandler(int location,
+                                 MessagePumpMojoHandler* handler,
                                  const Handle& handle,
                                  MojoHandleSignals wait_signals,
                                  base::TimeTicks deadline) {
   CHECK(handler);
   DCHECK(handle.is_valid());
   // Assume it's an error if someone tries to reregister an existing handle.
   CHECK_EQ(0u, handlers_.count(handle));
   Handler handler_data;
+  handler_data.location = location;
   handler_data.handler = handler;
   handler_data.wait_signals = wait_signals;
   handler_data.deadline = deadline;
   handler_data.id = next_handler_id_++;
   handlers_[handle] = handler_data;
 }
 
 void MessagePumpMojo::RemoveHandler(const Handle& handle) {
   handlers_.erase(handle);
 }
@@ skipping 96 matching lines @@
     switch (result) {
       case MOJO_RESULT_CANCELLED:
       case MOJO_RESULT_FAILED_PRECONDITION:
         RemoveInvalidHandle(wait_state, result, wait_many_result.index);
         break;
       case MOJO_RESULT_DEADLINE_EXCEEDED:
         did_work = false;
         break;
       default:
         base::debug::Alias(&result);
+        base::debug::Alias(&wait_many_result.index);
+        if (wait_many_result.IsIndexValid()) {
+          const int location = wait_state.locations[wait_many_result.index];
+          base::debug::Alias(&location);
+        }
+
         // Unexpected result is likely fatal, crash so we can determine cause.
         CHECK(false);
     }
   }
 
   // Notify and remove any handlers whose time has expired. Make a copy in case
   // someone tries to add/remove new handlers from notification.
   const HandleToHandler cloned_handlers(handlers_);
   const base::TimeTicks now(internal::NowTicks());
   for (HandleToHandler::const_iterator i = cloned_handlers.begin();
@@ skipping 39 matching lines @@
   // If we can't write we likely won't wake up the thread and there is a strong
   // chance we'll deadlock.
   CHECK_EQ(MOJO_RESULT_OK, result);
 }
 
 MessagePumpMojo::WaitState MessagePumpMojo::GetWaitState(
     const RunState& run_state) const {
   WaitState wait_state;
   wait_state.handles.push_back(run_state.read_handle.get());
   wait_state.wait_signals.push_back(MOJO_HANDLE_SIGNAL_READABLE);
+  wait_state.locations.push_back(6);
 
   for (HandleToHandler::const_iterator i = handlers_.begin();
        i != handlers_.end(); ++i) {
     wait_state.handles.push_back(i->first);
     wait_state.wait_signals.push_back(i->second.wait_signals);
+    wait_state.locations.push_back(i->second.location);
   }
   return wait_state;
 }
 
 MojoDeadline MessagePumpMojo::GetDeadlineForWait(
     const RunState& run_state) const {
   const base::TimeTicks now(internal::NowTicks());
   MojoDeadline deadline = TimeTicksToMojoDeadline(run_state.delayed_work_time,
                                                   now);
   for (HandleToHandler::const_iterator i = handlers_.begin();
        i != handlers_.end(); ++i) {
     deadline = std::min(
         TimeTicksToMojoDeadline(i->second.deadline, now), deadline);
   }
   return deadline;
 }
 
 void MessagePumpMojo::WillSignalHandler() {
   FOR_EACH_OBSERVER(Observer, observers_, WillSignalHandler());
 }
 
 void MessagePumpMojo::DidSignalHandler() {
   FOR_EACH_OBSERVER(Observer, observers_, DidSignalHandler());
 }
 
 }  // namespace common
 }  // namespace mojo