[mojo-edk] Expose notification source to MojoWatch callbacks

mojo/public/cpp/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_PUBLIC_CPP_SYSTEM_WATCHER_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_WATCHER_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 30 matching lines @@
   using ReadyCallback = base::Callback<void(MojoResult result)>;
 
   // TODO(rockot/yzshen): Support giving Watcher an explicit TaskRunner for
   // more fine-grained control over dispatch behavior.
   Watcher();
 
   // NOTE: This destructor automatically calls |Cancel()| if the Watcher is
   // still active.
   ~Watcher();
 
+  // Allows the watcher to dispatch notifications synchronously if notified on
+  // its own thread. This should be used with caution since it means watched
+  // endpoints may reenter each other.
+  void SetAllowSyncDispatch(bool allowed);
+
   // Indicates if the Watcher is currently watching a handle.
   bool IsWatching() const;
 
   // Starts watching |handle|. A Watcher may only watch one handle at a time,
   // but it is safe to call this more than once as long as the previous watch
   // has been cancelled (i.e. |is_watching()| returns |false|.)
   //
   // If no signals in |signals| can ever be satisfied for |handle|, this returns
   // |MOJO_RESULT_FAILED_PRECONDITION|.
   //
@@ skipping 39 matching lines @@
   base::WeakPtr<Watcher> weak_self_;
 
   // Fields below must only be accessed on the Watcher's owning thread.
 
   // The handle currently under watch. Not owned.
   Handle handle_;
 
   // The callback to call when the handle is signaled.
   ReadyCallback callback_;
 
+  bool allow_sync_dispatch_ = false;
+
   base::WeakPtrFactory<Watcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Watcher);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_WATCHER_H_