Initial stub version of Async Clipboard API

third_party/WebKit/Source/core/clipboard/ClipboardAsync.cpp

+// Copyright 2017 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/clipboard/ClipboardAsync.h"
+
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "core/clipboard/DataObject.h"
+#include "core/clipboard/DataTransfer.h"
+#include "core/clipboard/DataTransferItem.h"
+#include "core/clipboard/DataTransferItemList.h"
+#include "core/dom/TaskRunnerHelper.h"
+#include "platform/CrossThreadFunctional.h"
+#include "public/platform/Platform.h"
+
+namespace blink {
+
+ClipboardAsync* ClipboardAsync::create(ScriptState* scriptState) {
+  return new ClipboardAsync(scriptState);
+}
+
+ClipboardAsync::ClipboardAsync(ScriptState* scriptState)
+    : ContextLifecycleObserver(blink::ExecutionContext::From(scriptState)),
+      m_scriptPromiseResolver(ScriptPromiseResolver::Create(scriptState)),
+      m_buffer(WebClipboard::kBufferStandard) {}

[dcheng, 2017/05/13 22:18:32]

Out of curiosity, do you see this being used for non-clipboard purposes in the
future as well?

[garykac, 2017/05/17 23:51:14]

Probably not. So I removed CORE_EXPORT from the .h file.

+
+WebTaskRunner* ClipboardAsync::getTaskRunner() {
+  // TODO(garykac): Replace MiscPlatformAPI with TaskType specific to clipboard.
+  return TaskRunnerHelper::Get(TaskType::kMiscPlatformAPI,
+                               GetExecutionContext())
+      .Get();
+}
+
+ScriptPromise ClipboardAsync::scheduleRead() {
+  getTaskRunner()->PostTask(
+      BLINK_FROM_HERE,
+      WTF::Bind(&ClipboardAsync::handleRead, WrapPersistent(this)));
+  return m_scriptPromiseResolver->Promise();
+}
+
+ScriptPromise ClipboardAsync::scheduleReadText() {
+  getTaskRunner()->PostTask(
+      BLINK_FROM_HERE,
+      WTF::Bind(&ClipboardAsync::handleReadText, WrapPersistent(this)));
+  return m_scriptPromiseResolver->Promise();
+}
+
+ScriptPromise ClipboardAsync::scheduleWrite(DataTransfer* data) {
+  getTaskRunner()->PostTask(
+      BLINK_FROM_HERE, WTF::Bind(&ClipboardAsync::handleWrite,
+                                 WrapPersistent(this), WrapPersistent(data)));
+  return m_scriptPromiseResolver->Promise();
+}
+
+ScriptPromise ClipboardAsync::scheduleWriteText(const String& data) {
+  getTaskRunner()->PostTask(
+      BLINK_FROM_HERE,
+      WTF::Bind(&ClipboardAsync::handleWriteText, WrapPersistent(this), data));
+  return m_scriptPromiseResolver->Promise();
+}
+
+// TODO(garykac): This currently only handles plain text.
+void ClipboardAsync::handleRead() {
+  String plainText = Platform::Current()->Clipboard()->ReadPlainText(m_buffer);
+
+  DataTransfer::DataTransferType type =
+      DataTransfer::DataTransferType::kCopyAndPaste;
+  DataTransferAccessPolicy access =
+      DataTransferAccessPolicy::kDataTransferReadable;
+  DataObject* data = DataObject::CreateFromString(plainText);
+  DataTransfer* dt = DataTransfer::Create(type, access, data);
+  m_scriptPromiseResolver->Resolve(dt);
+}
+
+void ClipboardAsync::handleReadText() {
+  String text = Platform::Current()->Clipboard()->ReadPlainText(m_buffer);
+  m_scriptPromiseResolver->Resolve(text);
+}
+
+// TODO(garykac): This currently only handles plain text.
+void ClipboardAsync::handleWrite(DataTransfer* data) {
+  size_t nItems = data->items()->length();
+  for (unsigned long i = 0; i < nItems; i++) {
+    DataTransferItem* item = data->items()->item(i);
+    DataObjectItem* objectItem = item->GetDataObjectItem();
+    if (objectItem->Kind() == DataObjectItem::kStringKind &&
+        objectItem->GetType() == "text/plain") {
+      String text = objectItem->GetAsString();
+      Platform::Current()->Clipboard()->WritePlainText(text);
+      m_scriptPromiseResolver->Resolve();
+      return;
+    }
+  }
+  m_scriptPromiseResolver->Reject();
+}
+
+void ClipboardAsync::handleWriteText(const String& data) {
+  Platform::Current()->Clipboard()->WritePlainText(data);
+  m_scriptPromiseResolver->Resolve();
+}
+
+void ClipboardAsync::ContextDestroyed(ExecutionContext*) {
+  m_scriptPromiseResolver.Clear();

[dcheng, 2017/05/13 22:18:32]

As far as I can tell, we don't check that the m_scriptPromiseResolver is
non-null before using it in the handle* callbacks; will this crash if the
context is detached?

Also, I'm wondering if we need to do this at all: promises should already
observe the context and detach themselves if needed; is this to try to avoid
unnecessary work?

[garykac, 2017/05/17 23:51:14]

AIUI, the resolver sticks around until garbage collected and you can use
GetExecutionContext if you need to verify the context.

Resolving/rejecting the promise doesn't care about the ExecutionContext.
This is the pattern found elsewhere in the code with ScriptPromiseResolvers. For
example:
* WebKit/Source/modules/mediastream/MediaDevicesRequest.cpp
* WebKit/Source/modules/payments/PaymentRequest.cpp

I don't know enough about the plumbing here to know if it is unnecessary, but I
assume that it's being done for a good reason.

But I'm happy to remove it if it's not needed.

[dcheng, 2017/06/06 23:33:38]

Right--but if we call clear() here, Member<ScriptPromiseResolver> gets set to
null. So line 99 would crash if it executed on a detached context, right?
Reading the code suggests that trying to resolve or reject a promise for a
detached context will automatically become a no-op already:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/bindings/core/...

[garykac, 2017/06/09 20:38:59]

OK. I've removed the entire ContextDestroyed method since it doesn't appear to
be necessary.

+}
+
+DEFINE_TRACE(ClipboardAsync) {
+  visitor->Trace(m_scriptPromiseResolver);
+  ContextLifecycleObserver::Trace(visitor);
+}
+
+}  // namespace blink