Adds some code to help isolate where crash is happening

mojo/message_pump/handle_watcher.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/handle_watcher.h"
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 const char kWatcherThreadName[] = "handle-watcher-thread";
 
 base::TimeTicks MojoDeadlineToTimeTicks(MojoDeadline deadline) {
   return deadline == MOJO_DEADLINE_INDEFINITE ? base::TimeTicks() :
       internal::NowTicks() + base::TimeDelta::FromMicroseconds(deadline);
 }
 
 // Tracks the data for a single call to Start().
 struct WatchData {
   WatchData()
-      : id(0), handle_signals(MOJO_HANDLE_SIGNAL_NONE), task_runner(NULL) {}
+      : location(0),
+        id(0),
+        handle_signals(MOJO_HANDLE_SIGNAL_NONE),
+        task_runner(NULL) {}
 
+  int location;
   WatcherID id;
   Handle handle;
   MojoHandleSignals handle_signals;
   base::TimeTicks deadline;
   base::Callback<void(MojoResult)> callback;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner;
 };
 
 // WatcherBackend --------------------------------------------------------------
 
@@ skipping 35 matching lines @@
 
 WatcherBackend::~WatcherBackend() {
 }
 
 void WatcherBackend::StartWatching(const WatchData& data) {
   RemoveAndNotify(data.handle, MOJO_RESULT_CANCELLED);
 
   DCHECK_EQ(0u, handle_to_data_.count(data.handle));
 
   handle_to_data_[data.handle] = data;
-  MessagePumpMojo::current()->AddHandler(this, data.handle,
-                                         data.handle_signals,
-                                         data.deadline);
+  MessagePumpMojo::current()->AddHandler(data.location, this, data.handle,
+                                         data.handle_signals, data.deadline);
 }
 
 void WatcherBackend::StopWatching(WatcherID watcher_id) {
   // Because of the thread hop it is entirely possible to get here and not
   // have a valid handle registered for |watcher_id|.
   Handle handle;
   if (GetMojoHandleByWatcherID(watcher_id, &handle)) {
     handle_to_data_.erase(handle);
     MessagePumpMojo::current()->RemoveHandler(handle);
   }
@@ skipping 41 matching lines @@
  public:
   ~WatcherThreadManager();
 
   // Returns the shared instance.
   static WatcherThreadManager* GetInstance();
 
   // Starts watching the requested handle. Returns a unique ID that is used to
   // stop watching the handle. When the handle is ready |callback| is notified
   // on the thread StartWatching() was invoked on.
   // This may be invoked on any thread.
-  WatcherID StartWatching(const Handle& handle,
+  WatcherID StartWatching(int location,
+                          const Handle& handle,
                           MojoHandleSignals handle_signals,
                           base::TimeTicks deadline,
                           const base::Callback<void(MojoResult)>& callback);
 
   // Stops watching a handle.
   // This may be invoked on any thread.
   void StopWatching(WatcherID watcher_id);
 
  private:
   enum RequestType {
@@ skipping 42 matching lines @@
 
 WatcherThreadManager::~WatcherThreadManager() {
   thread_.Stop();
 }
 
 WatcherThreadManager* WatcherThreadManager::GetInstance() {
   return base::Singleton<WatcherThreadManager>::get();
 }
 
 WatcherID WatcherThreadManager::StartWatching(
+    int location,
     const Handle& handle,
     MojoHandleSignals handle_signals,
     base::TimeTicks deadline,
     const base::Callback<void(MojoResult)>& callback) {
   RequestData request_data;
   request_data.type = REQUEST_START;
+  request_data.start_data.location = location;
   request_data.start_data.id = watcher_id_generator_.GetNext();
   request_data.start_data.handle = handle;
   request_data.start_data.callback = callback;
   request_data.start_data.handle_signals = handle_signals;
   request_data.start_data.deadline = deadline;
   request_data.start_data.task_runner = base::ThreadTaskRunnerHandle::Get();
   AddRequest(request_data);
   return request_data.start_data.id;
 }
 
@@ skipping 120 matching lines @@
  public:
   SameThreadWatchingState(HandleWatcher* watcher,
                           const Handle& handle,
                           MojoHandleSignals handle_signals,
                           MojoDeadline deadline,
                           const base::Callback<void(MojoResult)>& callback)
       : StateBase(watcher, callback),
         handle_(handle) {
     DCHECK(MessagePumpMojo::IsCurrent());
 
-    MessagePumpMojo::current()->AddHandler(
-        this, handle, handle_signals, MojoDeadlineToTimeTicks(deadline));
+    MessagePumpMojo::current()->AddHandler(watcher->location(), this, handle,
+                                           handle_signals,
+                                           MojoDeadlineToTimeTicks(deadline));
   }
 
   ~SameThreadWatchingState() override {
     if (!got_ready())
       MessagePumpMojo::current()->RemoveHandler(handle_);
   }
 
  private:
   // MessagePumpMojoHandler overrides:
   void OnHandleReady(const Handle& handle) override {
@@ skipping 21 matching lines @@
 class HandleWatcher::SecondaryThreadWatchingState : public StateBase {
  public:
   SecondaryThreadWatchingState(HandleWatcher* watcher,
                                const Handle& handle,
                                MojoHandleSignals handle_signals,
                                MojoDeadline deadline,
                                const base::Callback<void(MojoResult)>& callback)
       : StateBase(watcher, callback),
         weak_factory_(this) {
     watcher_id_ = WatcherThreadManager::GetInstance()->StartWatching(
-        handle,
-        handle_signals,
+        watcher->location(), handle, handle_signals,
         MojoDeadlineToTimeTicks(deadline),
         base::Bind(&SecondaryThreadWatchingState::NotifyHandleReady,
                    weak_factory_.GetWeakPtr()));
   }
 
   ~SecondaryThreadWatchingState() override {
     // If we've been notified the handle is ready (|got_ready()| is true) then
     // the watch has been implicitly removed by
     // WatcherThreadManager/MessagePumpMojo and we don't have to call
     // StopWatching(). To do so would needlessly entail posting a task and
     // blocking until the background thread services it.
     if (!got_ready())
       WatcherThreadManager::GetInstance()->StopWatching(watcher_id_);
   }
 
  private:
   WatcherID watcher_id_;
 
   // Used to weakly bind |this| to the WatcherThreadManager.
   base::WeakPtrFactory<SecondaryThreadWatchingState> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SecondaryThreadWatchingState);
 };
 
 // HandleWatcher ---------------------------------------------------------------
 
-HandleWatcher::HandleWatcher() {
-}
+HandleWatcher::HandleWatcher(int location) : location_(location) {}
 
 HandleWatcher::~HandleWatcher() {
 }
 
 void HandleWatcher::Start(const Handle& handle,
                           MojoHandleSignals handle_signals,
                           MojoDeadline deadline,
                           const base::Callback<void(MojoResult)>& callback) {
   DCHECK(handle.is_valid());
   DCHECK_NE(MOJO_HANDLE_SIGNAL_NONE, handle_signals);
 
   // Need to clear the state before creating a new one.
   state_.reset();
   if (MessagePumpMojo::IsCurrent()) {
     state_.reset(new SameThreadWatchingState(
         this, handle, handle_signals, deadline, callback));
   } else {
     state_.reset(new SecondaryThreadWatchingState(
         this, handle, handle_signals, deadline, callback));
   }
 }
 
 void HandleWatcher::Stop() {
   state_.reset();
 }
 
 }  // namespace common
 }  // namespace mojo