Log stack trace when ObjectWatcher::StartWatching() is called.

base/win/object_watcher.cc

 // Copyright (c) 2012 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 "base/win/object_watcher.h"
 
 #include "base/bind.h"
+#include "base/debug/alias.h"
 #include "base/logging.h"
 
 namespace base {
 namespace win {
 
 //-----------------------------------------------------------------------------
 
 ObjectWatcher::ObjectWatcher()
     : weak_factory_(this),
       object_(NULL),
@@ skipping 15 matching lines @@
   // Since our job is to just notice when an object is signaled and report the
   // result back to this thread, we can just run on a Windows wait thread.
   DWORD wait_flags = WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE;
 
   // DoneWaiting can be synchronously called from RegisterWaitForSingleObject,
   // so set up all state now.
   callback_ = base::Bind(&ObjectWatcher::Signal, weak_factory_.GetWeakPtr(),
                          delegate);
   object_ = object;
   origin_loop_ = MessageLoop::current();
+  stack_trace_ = base::debug::StackTrace();
 
   if (!RegisterWaitForSingleObject(&wait_object_, object, DoneWaiting,
                                    this, INFINITE, wait_flags)) {
     NOTREACHED() << "RegisterWaitForSingleObject failed: " << GetLastError();
     object_ = NULL;
     wait_object_ = NULL;
     return false;
   }
 
   // We need to know if the current message loop is going away so we can
@@ skipping 37 matching lines @@
   ObjectWatcher* that = static_cast<ObjectWatcher*>(param);
   that->origin_loop_->PostTask(FROM_HERE, that->callback_);
   that->callback_.Reset();
 }
 
 void ObjectWatcher::Signal(Delegate* delegate) {
   // Signaling the delegate may result in our destruction or a nested call to
   // StartWatching(). As a result, we save any state we need and clear previous
   // watcher state before signaling the delegate.
   HANDLE object = object_;
+  // Alias the stack trace where the watch was started so it'll be available in
+  // minidumps.
+  base::debug::StackTrace stack_trace = stack_trace_;
+  base::debug::Alias(&stack_trace);
   StopWatching();
   delegate->OnObjectSignaled(object);
 }
 
 void ObjectWatcher::WillDestroyCurrentMessageLoop() {
   // Need to shutdown the watch so that we don't try to access the MessageLoop
   // after this point.
   StopWatching();
 }
 
 }  // namespace win
 }  // namespace base