Mojo: Don't hold a watch context ref in SimpleWatcher posted task

mojo/public/cpp/system/simple_watcher.h

 // Copyright 2017 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.
 
 #ifndef MOJO_PUBLIC_CPP_SYSTEM_SIMPLE_WATCHER_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_SIMPLE_WATCHER_H_
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 146 matching lines @@
 
   // Sets the tag used by the heap profiler.
   // |tag| must be a const string literal.
   void set_heap_profiler_tag(const char* heap_profiler_tag) {
     heap_profiler_tag_ = heap_profiler_tag;
   }
 
  private:
   class Context;
 
-  void OnHandleReady(scoped_refptr<const Context> context, MojoResult result);
+  void OnHandleReady(int watch_id, MojoResult result);
 
   base::ThreadChecker thread_checker_;
 
   // The policy used to determine how this SimpleWatcher is armed.
   const ArmingPolicy arming_policy_;
 
   // The TaskRunner of this SimpleWatcher's owning thread. This field is safe to
   // access from any thread.
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // Whether |task_runner_| is the same as base::ThreadTaskRunnerHandle::Get()
   // for the thread.
   const bool is_default_task_runner_;
 
   ScopedWatcherHandle watcher_handle_;
 
   // A thread-safe context object corresponding to the currently active watch,
   // if any.
   scoped_refptr<Context> context_;
 
   // Fields below must only be accessed on the SimpleWatcher's owning thread.
 
   // The handle currently under watch. Not owned.
   Handle handle_;
 
+  // A simple counter to disambiguate notifications from multiple watch contexts
+  // in the event that this SimpleWatcher cancels and watches multiple times.
+  int watch_id_ = 0;
+
   // The callback to call when the handle is signaled.
   ReadyCallback callback_;
 
   // Tracks if the SimpleWatcher has already notified of unsatisfiability. This
   // is used to prevent redundant notifications in AUTOMATIC mode.
   bool unsatisfiable_ = false;
 
   // Tag used to ID memory allocations that originated from notifications in
   // this watcher.
   const char* heap_profiler_tag_ = nullptr;
 
   base::WeakPtrFactory<SimpleWatcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleWatcher);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_SIMPLE_WATCHER_H_