Mojo: Armed Watchers

third_party/WebKit/Source/core/mojo/MojoWatcher.cpp

Index: third_party/WebKit/Source/core/mojo/MojoWatcher.cpp
diff --git a/third_party/WebKit/Source/core/mojo/MojoWatcher.cpp b/third_party/WebKit/Source/core/mojo/MojoWatcher.cpp
index 804536d40d710b92a73294c1b43e30129550f58e..c7d701bf4c144116ade73526b78cb012035bd88a 100644
--- a/third_party/WebKit/Source/core/mojo/MojoWatcher.cpp
+++ b/third_party/WebKit/Source/core/mojo/MojoWatcher.cpp
@@ -20,6 +20,7 @@ static void runWatchCallback(MojoWatchCallback* callback,
   callback->call(wrappable, result);
 }
 
+// static
 MojoWatcher* MojoWatcher::create(mojo::Handle handle,
                                  const MojoHandleSignals& signalsDict,
                                  MojoWatchCallback* callback,
@@ -27,8 +28,8 @@ MojoWatcher* MojoWatcher::create(mojo::Handle handle,
   MojoWatcher* watcher = new MojoWatcher(context, callback);
   MojoResult result = watcher->watch(handle, signalsDict);
   // TODO(alokp): Consider raising an exception.
-  // Current clients expect to recieve the initial error returned by MojoWatch
-  // via watch callback.
+  // Current clients expect to recieve the initial error returned by
+  // MojoRegisterWatcher via watch callback.
   //
   // Note that the usage of wrapPersistent is intentional so that the intial
   // error is guaranteed to be reported to the client in case where the given
@@ -39,43 +40,20 @@ MojoWatcher* MojoWatcher::create(mojo::Handle handle,
         BLINK_FROM_HERE, WTF::bind(&runWatchCallback, wrapPersistent(callback),
                                    wrapPersistent(watcher), result));
   }
+
   return watcher;
 }
 
-MojoWatcher::MojoWatcher(ExecutionContext* context, MojoWatchCallback* callback)
-    : ContextLifecycleObserver(context),
-      m_taskRunner(TaskRunnerHelper::get(TaskType::UnspecedTimer, context)),
-      m_callback(this, callback) {}
-
 MojoWatcher::~MojoWatcher() {
   DCHECK(!m_handle.is_valid());
 }
 
-MojoResult MojoWatcher::watch(mojo::Handle handle,
-                              const MojoHandleSignals& signalsDict) {
-  ::MojoHandleSignals signals = MOJO_HANDLE_SIGNAL_NONE;
-  if (signalsDict.readable())
-    signals |= MOJO_HANDLE_SIGNAL_READABLE;
-  if (signalsDict.writable())
-    signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
-  if (signalsDict.peerClosed())
-    signals |= MOJO_HANDLE_SIGNAL_PEER_CLOSED;
-
-  MojoResult result =
-      MojoWatch(handle.value(), signals, &MojoWatcher::onHandleReady,
-                reinterpret_cast<uintptr_t>(this));
-  if (result == MOJO_RESULT_OK) {
-    m_handle = handle;
-  }
-  return result;
-}
-
 MojoResult MojoWatcher::cancel() {
   if (!m_handle.is_valid())
     return MOJO_RESULT_OK;
 
-  MojoResult result =
-      MojoCancelWatch(m_handle.value(), reinterpret_cast<uintptr_t>(this));
+  MojoResult result = MojoUnregisterWatcher(m_handle.value(),
+                                            reinterpret_cast<uintptr_t>(this));
   m_handle = mojo::Handle();
   return result;
 }
@@ -97,13 +75,54 @@ void MojoWatcher::contextDestroyed(ExecutionContext*) {
   cancel();
 }
 
+MojoWatcher::MojoWatcher(ExecutionContext* context, MojoWatchCallback* callback)
+    : ContextLifecycleObserver(context),
+      m_taskRunner(TaskRunnerHelper::get(TaskType::UnspecedTimer, context)),
+      m_callback(this, callback) {}
+
+MojoResult MojoWatcher::watch(mojo::Handle handle,
+                              const MojoHandleSignals& signalsDict) {
+  ::MojoHandleSignals signals = MOJO_HANDLE_SIGNAL_NONE;
+  if (signalsDict.readable())
+    signals |= MOJO_HANDLE_SIGNAL_READABLE;
+  if (signalsDict.writable())
+    signals |= MOJO_HANDLE_SIGNAL_WRITABLE;
+  if (signalsDict.peerClosed())
+    signals |= MOJO_HANDLE_SIGNAL_PEER_CLOSED;
+
+  MojoResult result =
+      MojoRegisterWatcher(handle.value(), signals, &MojoWatcher::onHandleReady,
+                          reinterpret_cast<uintptr_t>(this));
+  if (result == MOJO_RESULT_OK) {
+    m_handle = handle;
+    arm();
+  }
+  return result;
+}
+
+void MojoWatcher::arm() {
+  // Nothing to do if the watcher is inactive.
+  if (!m_handle.is_valid())
+    return;
+
+  MojoResult result =
+      MojoArmWatcher(m_handle.value(), reinterpret_cast<uintptr_t>(this));
+  if (result == MOJO_RESULT_OK)
+    return;
+  if (result == MOJO_RESULT_ALREADY_EXISTS)
+    result = MOJO_RESULT_OK;
+  m_taskRunner->postTask(
+      BLINK_FROM_HERE,
+      WTF::bind(&MojoWatcher::runReadyCallback, wrapPersistent(this), result));
+}
+
 void MojoWatcher::onHandleReady(uintptr_t context,
                                 MojoResult result,
                                 MojoHandleSignalsState,
                                 MojoWatchNotificationFlags) {
   // It is safe to assume the MojoWatcher still exists because this
   // callback will never be run after MojoWatcher destructor,
-  // which cancels the watch.
+  // which unregisters the watcher.
   MojoWatcher* watcher = reinterpret_cast<MojoWatcher*>(context);
   watcher->m_taskRunner->postTask(
       BLINK_FROM_HERE,
@@ -117,12 +136,15 @@ void MojoWatcher::runReadyCallback(MojoResult result) {
     return;
 
   // MOJO_RESULT_CANCELLED indicates that the handle has been closed, in which
-  // case watch has been implicitly cancelled. There is no need to explicitly
-  // cancel the watch.
+  // case watcher has been implicitly cancelled. There is no need to explicitly
+  // cancel the watcher.
   if (result == MOJO_RESULT_CANCELLED)
     m_handle = mojo::Handle();
 
   runWatchCallback(m_callback, this, result);
+
+  // Rearm the watcher so another notification can fire.
+  arm();

[yzshen1, 2017/03/03 00:03:50]

Will it make things simpler if we use mojo::Watcher instead of the raw C API? 

[Ken Rockot(use gerrit already), 2017/03/03 00:37:05]

Yes, most certainly, but I assume it will result in an argument over Blink
depending on mojo/public/cpp/system, so I'd rather hold off on that.

 }
 
 }  // namespace blink