Adds Mojo IDL.

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
new file mode 100644
index 0000000000000000000000000000000000000000..412ce4058c6ea4c950f58412ea5b501505b1cec3
--- /dev/null
+++ b/third_party/WebKit/Source/core/mojo/MojoWatcher.cpp
@@ -0,0 +1,82 @@
+// 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.
+
+#include "core/mojo/MojoWatcher.h"
+
+#include "bindings/core/v8/MojoWatchCallback.h"
+#include "bindings/core/v8/ScriptState.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/dom/ExecutionContextTask.h"
+
+namespace blink {
+
+MojoWatcher* MojoWatcher::create(mojo::Handle handle,
+                                 MojoHandleSignals signals,
+                                 MojoWatchCallback* callback,
+                                 ExecutionContext* taskRunner) {
+  MojoWatcher* watcher = new MojoWatcher(handle, callback, taskRunner);
+
+  MojoResult result =
+      MojoWatch(handle.value(), signals, &MojoWatcher::onHandleReady,
+                reinterpret_cast<uintptr_t>(watcher));
+  // TODO(alokp): Consider raising an exception.
+  // Current clients expect to recieve the initial error returned by MojoWatch
+  // via watch callback.
+  if (result != MOJO_RESULT_OK) {
+    watcher->m_taskRunner->postTask(
+        BLINK_FROM_HERE,
+        createSameThreadTask(&MojoWatcher::runReadyCallback,
+                             wrapWeakPersistent(watcher), result));
+  }
+  return watcher;
+}
+
+MojoWatcher::MojoWatcher(mojo::Handle handle,
+                         MojoWatchCallback* callback,
+                         ExecutionContext* taskRunner)
+    : m_handle(handle), m_callback(this, callback), m_taskRunner(taskRunner) {}
+
+MojoWatcher::~MojoWatcher() {
+  cancel();

[jbroman, 2017/01/10 20:46:31]

Hold on, what stops this from being cancelled the next time GC happens? It's
unusual in JS to expect visible effects from finalization of objects (you're
usually permitted to just drop references to things you don't care about).

If I write:

handle.watch(signals, result => {
  // ...
});

and I'm not interested in cancelling the watch ever (well, more likely, until
context shutdown)

I think this object probably needs to be ActiveScriptWrappable so that it's kept
alive while the context is alive and it has pending activity (which is probably
"the watch is not cancelled").

[alokp, 2017/01/11 21:53:02]

Done.

+}
+
+MojoResult MojoWatcher::cancel() {
+  MojoResult result = MOJO_RESULT_OK;
+  if (m_handle.is_valid()) {
+    result =
+        MojoCancelWatch(m_handle.value(), reinterpret_cast<uintptr_t>(this));
+    m_handle = mojo::Handle();
+  }
+  return result;
+}
+
+DEFINE_TRACE_WRAPPERS(MojoWatcher) {
+  visitor->traceWrappers(m_callback);
+}
+
+void MojoWatcher::onHandleReady(uintptr_t context,
+                                MojoResult result,
+                                MojoHandleSignalsState,

[jbroman, 2017/01/10 20:46:31]

Does script not need to know which signals are ready? Is it expected that this
will be added in the future, or is it never needed?

[alokp, 2017/01/11 21:53:02]

C API currently does not specify the signals for which callback is fired. The
current usage also only specifies one of the two signals - readable or writable.
Whether this will change in future is a question for mojo team. yzshen/rockot?

[yzshen1, 2017/01/12 23:38:34]

I don't think it is super useful. I am fine not having it for now.

+                                MojoWatchNotificationFlags) {
+  // It is safe to assume the MojoWatcher still exists because this
+  // callback will never be run after MojoWatcher destructor,
+  // which cancels the watch.
+  MojoWatcher* watcher = reinterpret_cast<MojoWatcher*>(context);
+  watcher->m_taskRunner->postTask(
+      BLINK_FROM_HERE,
+      createCrossThreadTask(&MojoWatcher::runReadyCallback,
+                            wrapCrossThreadWeakPersistent(watcher), result));
+}
+
+void MojoWatcher::runReadyCallback(MojoResult result) {
+  if (!m_handle.is_valid())
+    return;
+
+  if (result != MOJO_RESULT_OK)
+    cancel();
+
+  m_callback->call(this, result);
+}
+
+}  // namespace blink