[ObjectWatcher]: Add from_here to ObjectWatcher::StartWatching*

To investigate BLOCK_SHUTDOWN tasks posted after shutdown (see bug).

Bug: 997754
Change-Id: Ie939ee242f56ab4ba25e6a67d640ad7873d3ad4b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1827938Reviewed-by: Bruce Dawson <brucedawson@chromium.org>
Commit-Queue: Etienne Pierre-Doray <etiennep@chromium.org>
Cr-Commit-Position: refs/heads/master@{#701680}

base/win/object_watcher.cc

@@ -21,13 +21,16 @@ ObjectWatcher::~ObjectWatcher() {
   StopWatching();
 }
 
-bool ObjectWatcher::StartWatchingOnce(HANDLE object, Delegate* delegate) {
-  return StartWatchingInternal(object, delegate, true);
+bool ObjectWatcher::StartWatchingOnce(HANDLE object,
+                                      Delegate* delegate,
+                                      const Location& from_here) {
+  return StartWatchingInternal(object, delegate, true, from_here);
 }
 
 bool ObjectWatcher::StartWatchingMultipleTimes(HANDLE object,
-                                               Delegate* delegate) {
-  return StartWatchingInternal(object, delegate, false);
+                                               Delegate* delegate,
+                                               const Location& from_here) {
+  return StartWatchingInternal(object, delegate, false, from_here);
 }
 
 bool ObjectWatcher::StopWatching() {
@@ -63,17 +66,20 @@ void CALLBACK ObjectWatcher::DoneWaiting(void* param, BOOLEAN timed_out) {
   // The destructor blocks on any callbacks that are in flight, so we know that
   // that is always a pointer to a valid ObjectWater.
   ObjectWatcher* that = static_cast<ObjectWatcher*>(param);
-  that->task_runner_->PostTask(FROM_HERE, that->callback_);
+  that->task_runner_->PostTask(that->location_, that->callback_);
   if (that->run_once_)
     that->callback_.Reset();
 }
 
-bool ObjectWatcher::StartWatchingInternal(HANDLE object, Delegate* delegate,
-                                          bool execute_only_once) {
+bool ObjectWatcher::StartWatchingInternal(HANDLE object,
+                                          Delegate* delegate,
+                                          bool execute_only_once,
+                                          const Location& from_here) {
   DCHECK(delegate);
   DCHECK(!wait_object_) << "Already watching an object";
   DCHECK(SequencedTaskRunnerHandle::IsSet());
 
+  location_ = from_here;
   task_runner_ = SequencedTaskRunnerHandle::Get();
 
   run_once_ = execute_only_once;
@@ -112,6 +118,7 @@ void ObjectWatcher::Signal(Delegate* delegate) {
 
 void ObjectWatcher::Reset() {
   callback_.Reset();
+  location_ = {};
   object_ = nullptr;
   wait_object_ = nullptr;
   task_runner_ = nullptr;

base/win/object_watcher.h

@@ -71,14 +71,19 @@ class BASE_EXPORT ObjectWatcher {
   // where StartWatchingOnce is called. The ObjectWatcher is not responsible for
   // deleting the delegate.
   // Returns whether watching was successfully initiated.
-  bool StartWatchingOnce(HANDLE object, Delegate* delegate);
+  bool StartWatchingOnce(HANDLE object,
+                         Delegate* delegate,
+                         const Location& from_here = Location::Current());
 
   // Notifies the delegate, on the sequence where this method is called, each
   // time the object is set. By definition, the handle must be an auto-reset
   // object. The caller must ensure that it (or any Windows system code) doesn't
   // reset the event or else the delegate won't be called.
   // Returns whether watching was successfully initiated.
-  bool StartWatchingMultipleTimes(HANDLE object, Delegate* delegate);
+  bool StartWatchingMultipleTimes(
+      HANDLE object,
+      Delegate* delegate,
+      const Location& from_here = Location::Current());
 
   // Stops watching.  Does nothing if the watch has already completed.  If the
   // watch is still active, then it is canceled, and the associated delegate is
@@ -98,13 +103,17 @@ class BASE_EXPORT ObjectWatcher {
   static void CALLBACK DoneWaiting(void* param, BOOLEAN timed_out);
 
   // Helper used by StartWatchingOnce and StartWatchingMultipleTimes.
-  bool StartWatchingInternal(HANDLE object, Delegate* delegate,
-                             bool execute_only_once);
+  bool StartWatchingInternal(HANDLE object,
+                             Delegate* delegate,
+                             bool execute_only_once,
+                             const Location& from_here);
 
   void Signal(Delegate* delegate);
 
   void Reset();
 
+  Location location_;
+
   // A callback pre-bound to Signal() that is posted to the caller's task runner
   // when the wait completes.
   RepeatingClosure callback_;