Adds Mojo IDL.

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

+// 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,
+                                 ScriptState* scriptState,
+                                 MojoWatchCallback* callback) {
+  MojoWatcher* watcher = new MojoWatcher(handle, scriptState, callback);
+
+  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,
+                         ScriptState* scriptState,
+                         MojoWatchCallback* callback)
+    : m_handle(handle),
+      m_scriptState(scriptState),
+      m_callback(callback),
+      m_taskRunner(scriptState->getExecutionContext()) {}
+
+MojoWatcher::~MojoWatcher() {
+  cancel();
+}
+
+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(MojoWatcher) {
+  visitor->trace(m_callback);
+}
+
+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.
+  MojoWatcher* watcher = reinterpret_cast<MojoWatcher*>(context);
+  watcher->m_taskRunner->postTask(

[jbroman, 2016/12/20 23:21:57]

Even though this reference to ExecutionContext is thread-safe, ExecutionContext
itself is not.

In addition, though watcher is guaranteed to still exist, the ExecutionContext
is not (at least, not obviously), since it does not hold a strong reference. I
think you want to hold std::unique_ptr<WebTaskRunner> instead, which should be
thread-safe.

[alokp, 2017/01/09 23:33:10]

Hmm I see multiple other instances of cross-thread postTask. For example:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/dom/Messa...
I used WebTaskRunner in earlier versions of this patch, but I ran into an issue
where layout tests using mojo did not terminate. MojoWatcher would continue to
fire ready callbacks. Elliot suggested using the task runner from
ExecutionContext because WebTaskRunner bypasses the scheduler. Making the change
fixed those layout tests as well. Is there a way to extract a thread-safe task
runner from ExecutionContext?

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

I believe that is probably safe, but for subtle reasons, because of the use of a
lock on the Chromium side:

- If the MessagePort or its context are destroyed, MessagePort::close will call
WebMessagePortChannelImpl::setClient (with nullptr) which acquires its lock.
- MessagePort::messageAvailable is only called off-thread by
WebMessagePortChannelImpl::OnMessage, which holds the same lock.
- It happens that there don't seem to be any other methods that mutate that
state on the main thread at present.

Thus it is sequenced so that the destruction of the execution context and the
processing of the message do not occur simultaneously.

If you do (as I think you should in any event, see below) stop the watch when
the context is destroyed (using the lock that I believe Mojo has internally),
then this might be safe. But I think it's unnecessarily precarious, and
ExecutionContext does not make a general promise that ExecutionContext::postTask
doesn't mutate any other main thread state. WebTaskRunner does have that
contract.

(esprehn may disagree with me; I haven't discussed this with him.)
This object should clean itself up when the context is destroyed, by subclassing
ContextLifecycleObserver (unless it's changed due to haraken's recent changes).
At that point it can cancel itself, which should deal with this.


I'm not sure what was meant by "bypassing the scheduler". There may be task
runners that do, but if you get one of the categorized task runners from
TaskRunnerHelper, those tasks should be managed by the scheduler.

Something like this should work, I believe:

// on the main thread, when the MojoWatcher is created
std::unique_ptr<WebTaskRunner> taskRunner = TaskRunnerHelper::get(TaskType::Mojo
/* or one of the existing ones */, scriptState->getExecutionContext())->clone();

This will create a WebTaskRunner which this object owns, but which shares the
same (thread-safe) task queue as the one owned from the main thread.

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

Thanks for the code snippet. It works. Done.

+      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(m_scriptState, this, result);

[jbroman, 2016/12/20 23:21:57]

I don't think m_scriptState is needed for this (and thus, anything in this
class) anymore.

[alokp, 2017/01/09 23:33:10]

Done.

+}
+
+}  // namespace blink