[mojo-edk] Expose notification source to MojoWatch callbacks

mojo/edk/system/watcher.h

 // Copyright 2016 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_EDK_SYSTEM_WATCHER_H_
 #define MOJO_EDK_SYSTEM_WATCHER_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 11 matching lines @@
 // An event may occur at any time which should trigger a Watcher to run its
 // callback, but the callback needs to be deferred until all EDK locks are
 // released. At the same time, a watch may be cancelled at any time by
 // |MojoCancelWatch()| and it is not OK for the callback to be invoked after
 // that happens.
 //
 // Therefore a Watcher needs to have some associated thread-safe state to track
 // its cancellation, which is why it's ref-counted.
 class Watcher : public base::RefCountedThreadSafe<Watcher> {
  public:
-  using WatchCallback =
-      base::Callback<void(MojoResult, const HandleSignalsState&)>;
+  using WatchCallback = base::Callback<void(MojoResult,
+                                            const HandleSignalsState&,
+                                            MojoWatchNotificationFlags)>;
 
   // Constructs a new Watcher which watches for |signals| to be satisfied on a
   // handle and which invokes |callback| either when one such signal is
   // satisfied, or all such signals become unsatisfiable.
   Watcher(MojoHandleSignals signals, const WatchCallback& callback);
 
   // Runs the Watcher's callback with the given arguments if it hasn't been
   // cancelled yet.
-  void MaybeInvokeCallback(MojoResult result, const HandleSignalsState& state);
+  void MaybeInvokeCallback(MojoResult result,
+                           const HandleSignalsState& state,
+                           MojoWatchNotificationFlags flags);
 
   // Notifies the Watcher of a state change. This may result in the Watcher
   // adding a finalizer to the current RequestContext to invoke its callback,
   // cancellation notwithstanding.
   void NotifyForStateChange(const HandleSignalsState& signals_state);
 
   // Notifies the Watcher of handle closure. This always results in the Watcher
   // adding a finalizer to the current RequestContext to invoke its callback,
   // cancellation notwithstanding.
   void NotifyClosed();
@@ skipping 23 matching lines @@
   // hence this flag.
   bool is_cancelled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(Watcher);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_WATCHER_H_