Adjust some worker APIs to use BlinkTransferableMessage

Since we want to indicate the user gesture to postMessage to a
dedicated worker it is cleaner to adjust the worker APIs to take
a BlinkTransferableMessage.

This change is intended to have no behavioral change.

BUG=861735

Change-Id: I825d886877ae0931ce979c6b28930f754349dd9f
Reviewed-on: https://chromium-review.googlesource.com/1183288
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#585061}

third_party/blink/renderer/core/messaging/blink_transferable_message.h

@@ -12,6 +12,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/messaging/blink_cloneable_message.h"
+#include "third_party/blink/renderer/platform/cross_thread_copier.h"
 
 namespace blink {
 
@@ -44,6 +45,15 @@ CORE_EXPORT BlinkTransferableMessage
 // longer.
 CORE_EXPORT TransferableMessage ToTransferableMessage(BlinkTransferableMessage);
 
+template <>
+struct CrossThreadCopier<BlinkTransferableMessage> {
+  STATIC_ONLY(CrossThreadCopier);
+  using Type = BlinkTransferableMessage;
+  static Type Copy(Type pointer) {
+    return pointer;  // This is in fact a move.
+  }
+};
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_MESSAGING_BLINK_TRANSFERABLE_MESSAGE_H_

third_party/blink/renderer/core/workers/dedicated_worker.cc

@@ -135,6 +135,7 @@ void DedicatedWorker::postMessage(ScriptState* script_state,
                                   ExceptionState& exception_state) {
   DCHECK(GetExecutionContext()->IsContextThread());
 
+  BlinkTransferableMessage transferable_message;
   Transferables transferables;
   scoped_refptr<SerializedScriptValue> serialized_message =
       PostMessageHelper::SerializeMessageByMove(script_state->GetIsolate(),
@@ -143,18 +144,20 @@ void DedicatedWorker::postMessage(ScriptState* script_state,
   if (exception_state.HadException())
     return;
   DCHECK(serialized_message);
+  transferable_message.message = serialized_message;
 
   // Disentangle the port in preparation for sending it to the remote context.
-  auto channels = MessagePort::DisentanglePorts(
+  transferable_message.ports = MessagePort::DisentanglePorts(
       ExecutionContext::From(script_state), transferables.message_ports,
       exception_state);
   if (exception_state.HadException())
     return;
-  v8_inspector::V8StackTraceId stack_id =
+
+  transferable_message.sender_stack_trace_id =
       ThreadDebugger::From(script_state->GetIsolate())
           ->StoreCurrentStackTrace("Worker.postMessage");
-  context_proxy_->PostMessageToWorkerGlobalScope(std::move(serialized_message),
-                                                 std::move(channels), stack_id);
+  context_proxy_->PostMessageToWorkerGlobalScope(
+      std::move(transferable_message));
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#worker-processing-model

third_party/blink/renderer/core/workers/dedicated_worker_global_scope.cc

@@ -106,17 +106,19 @@ void DedicatedWorkerGlobalScope::postMessage(ScriptState* script_state,
   if (exception_state.HadException())
     return;
   DCHECK(serialized_message);
+  BlinkTransferableMessage transferable_message;
+  transferable_message.message = serialized_message;
   // Disentangle the port in preparation for sending it to the remote context.
-  auto channels = MessagePort::DisentanglePorts(
+  transferable_message.ports = MessagePort::DisentanglePorts(
       ExecutionContext::From(script_state), transferables.message_ports,
       exception_state);
   if (exception_state.HadException())
     return;
   ThreadDebugger* debugger = ThreadDebugger::From(script_state->GetIsolate());
-  v8_inspector::V8StackTraceId stack_id =
+  transferable_message.sender_stack_trace_id =
       debugger->StoreCurrentStackTrace("postMessage");
-  WorkerObjectProxy().PostMessageToWorkerObject(std::move(serialized_message),
-                                                std::move(channels), stack_id);
+  WorkerObjectProxy().PostMessageToWorkerObject(
+      std::move(transferable_message));
 }
 
 DedicatedWorkerObjectProxy& DedicatedWorkerGlobalScope::WorkerObjectProxy()

third_party/blink/renderer/core/workers/dedicated_worker_messaging_proxy.cc

@@ -14,6 +14,7 @@
 #include "third_party/blink/renderer/core/fetch/request.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
 #include "third_party/blink/renderer/core/inspector/thread_debugger.h"
+#include "third_party/blink/renderer/core/messaging/blink_transferable_message.h"
 #include "third_party/blink/renderer/core/workers/dedicated_worker.h"
 #include "third_party/blink/renderer/core/workers/dedicated_worker_object_proxy.h"
 #include "third_party/blink/renderer/core/workers/dedicated_worker_thread.h"
@@ -25,12 +26,6 @@
 
 namespace blink {
 
-struct DedicatedWorkerMessagingProxy::QueuedTask {
-  scoped_refptr<SerializedScriptValue> message;
-  Vector<MessagePortChannel> channels;
-  v8_inspector::V8StackTraceId stack_id;
-};
-
 DedicatedWorkerMessagingProxy::DedicatedWorkerMessagingProxy(
     ExecutionContext* execution_context,
     DedicatedWorker* worker_object)
@@ -76,24 +71,21 @@ void DedicatedWorkerMessagingProxy::StartWorkerGlobalScope(
 }
 
 void DedicatedWorkerMessagingProxy::PostMessageToWorkerGlobalScope(
-    scoped_refptr<SerializedScriptValue> message,
-    Vector<MessagePortChannel> channels,
-    const v8_inspector::V8StackTraceId& stack_id) {
+    BlinkTransferableMessage message) {
   DCHECK(IsParentContextThread());
   if (AskedToTerminate())
     return;
   if (!was_script_evaluated_) {
-    queued_early_tasks_.push_back(
-        QueuedTask{std::move(message), std::move(channels), stack_id});
+    queued_early_tasks_.push_back(std::move(message));
     return;
   }
   PostCrossThreadTask(
       *GetWorkerThread()->GetTaskRunner(TaskType::kPostedMessage), FROM_HERE,
       CrossThreadBind(
           &DedicatedWorkerObjectProxy::ProcessMessageFromWorkerObject,
-          CrossThreadUnretained(&WorkerObjectProxy()), std::move(message),
-          WTF::Passed(std::move(channels)),
-          CrossThreadUnretained(GetWorkerThread()), stack_id));
+          CrossThreadUnretained(&WorkerObjectProxy()),
+          WTF::Passed(std::move(message)),
+          CrossThreadUnretained(GetWorkerThread())));
 }
 
 bool DedicatedWorkerMessagingProxy::HasPendingActivity() const {
@@ -105,7 +97,7 @@ void DedicatedWorkerMessagingProxy::DidEvaluateScript(bool success) {
   DCHECK(IsParentContextThread());
   was_script_evaluated_ = true;
 
-  Vector<QueuedTask> tasks;
+  Vector<BlinkTransferableMessage> tasks;
   queued_early_tasks_.swap(tasks);
 
   // The worker thread can already be terminated.
@@ -123,28 +115,25 @@ void DedicatedWorkerMessagingProxy::DidEvaluateScript(bool success) {
         CrossThreadBind(
             &DedicatedWorkerObjectProxy::ProcessMessageFromWorkerObject,
             CrossThreadUnretained(&WorkerObjectProxy()),
-            WTF::Passed(std::move(task.message)),
-            WTF::Passed(std::move(task.channels)),
-            CrossThreadUnretained(GetWorkerThread()), task.stack_id));
+            WTF::Passed(std::move(task)),
+            CrossThreadUnretained(GetWorkerThread())));
   }
 }
 
 void DedicatedWorkerMessagingProxy::PostMessageToWorkerObject(
-    scoped_refptr<SerializedScriptValue> message,
-    Vector<MessagePortChannel> channels,
-    const v8_inspector::V8StackTraceId& stack_id) {
+    BlinkTransferableMessage message) {
   DCHECK(IsParentContextThread());
   if (!worker_object_ || AskedToTerminate())
     return;
 
   ThreadDebugger* debugger =
       ThreadDebugger::From(ToIsolate(GetExecutionContext()));
-  MessagePortArray* ports =
-      MessagePort::EntanglePorts(*GetExecutionContext(), std::move(channels));
-  debugger->ExternalAsyncTaskStarted(stack_id);
+  MessagePortArray* ports = MessagePort::EntanglePorts(
+      *GetExecutionContext(), std::move(message.ports));
+  debugger->ExternalAsyncTaskStarted(message.sender_stack_trace_id);
   worker_object_->DispatchEvent(
-      *MessageEvent::Create(ports, std::move(message)));
-  debugger->ExternalAsyncTaskFinished(stack_id);
+      *MessageEvent::Create(ports, std::move(message.message)));
+  debugger->ExternalAsyncTaskFinished(message.sender_stack_trace_id);
 }
 
 void DedicatedWorkerMessagingProxy::DispatchErrorEvent(

third_party/blink/renderer/core/workers/dedicated_worker_messaging_proxy.h

@@ -9,6 +9,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/optional.h"
+#include "third_party/blink/public/mojom/message_port/message_port.mojom-blink.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/core/workers/global_scope_creation_params.h"
@@ -17,16 +18,11 @@
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/weborigin/referrer_policy.h"
 
-namespace v8_inspector {
-struct V8StackTraceId;
-}
-
 namespace blink {
 
 class DedicatedWorker;
 class DedicatedWorkerObjectProxy;
 class FetchClientSettingsObjectSnapshot;
-class SerializedScriptValue;
 class WorkerOptions;
 
 // A proxy class to talk to the DedicatedWorkerGlobalScope on a worker thread
@@ -46,18 +42,14 @@ class CORE_EXPORT DedicatedWorkerMessagingProxy
       FetchClientSettingsObjectSnapshot* outside_settings_object,
       const v8_inspector::V8StackTraceId&,
       const String& source_code);
-  void PostMessageToWorkerGlobalScope(scoped_refptr<SerializedScriptValue>,
-                                      Vector<MessagePortChannel>,
-                                      const v8_inspector::V8StackTraceId&);
+  void PostMessageToWorkerGlobalScope(BlinkTransferableMessage);
 
   bool HasPendingActivity() const;
 
   // These methods come from worker context thread via
   // DedicatedWorkerObjectProxy and are called on the parent context thread.
   void DidEvaluateScript(bool success);
-  void PostMessageToWorkerObject(scoped_refptr<SerializedScriptValue>,
-                                 Vector<MessagePortChannel>,
-                                 const v8_inspector::V8StackTraceId&);
+  void PostMessageToWorkerObject(BlinkTransferableMessage);
   void DispatchErrorEvent(const String& error_message,
                           std::unique_ptr<SourceLocation>,
                           int exception_id);
@@ -92,8 +84,7 @@ class CORE_EXPORT DedicatedWorkerMessagingProxy
 
   // Tasks are queued here until worker scripts are evaluated on the worker
   // global scope.
-  struct QueuedTask;
-  Vector<QueuedTask> queued_early_tasks_;
+  Vector<BlinkTransferableMessage> queued_early_tasks_;
   DISALLOW_COPY_AND_ASSIGN(DedicatedWorkerMessagingProxy);
 };
 

third_party/blink/renderer/core/workers/dedicated_worker_object_proxy.cc

@@ -41,6 +41,7 @@
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/events/message_event.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
+#include "third_party/blink/renderer/core/frame/user_activation.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/inspector/thread_debugger.h"
 #include "third_party/blink/renderer/core/workers/dedicated_worker_messaging_proxy.h"
@@ -64,31 +65,28 @@ std::unique_ptr<DedicatedWorkerObjectProxy> DedicatedWorkerObjectProxy::Create(
 DedicatedWorkerObjectProxy::~DedicatedWorkerObjectProxy() = default;
 
 void DedicatedWorkerObjectProxy::PostMessageToWorkerObject(
-    scoped_refptr<SerializedScriptValue> message,
-    Vector<MessagePortChannel> channels,
-    const v8_inspector::V8StackTraceId& stack_id) {
+    BlinkTransferableMessage message) {
   PostCrossThreadTask(
       *GetParentExecutionContextTaskRunners()->Get(TaskType::kPostedMessage),
       FROM_HERE,
       CrossThreadBind(&DedicatedWorkerMessagingProxy::PostMessageToWorkerObject,
-                      messaging_proxy_weak_ptr_, std::move(message),
-                      WTF::Passed(std::move(channels)), stack_id));
+                      messaging_proxy_weak_ptr_,
+                      WTF::Passed(std::move(message))));
 }
 
 void DedicatedWorkerObjectProxy::ProcessMessageFromWorkerObject(
-    scoped_refptr<SerializedScriptValue> message,
-    Vector<MessagePortChannel> channels,
-    WorkerThread* worker_thread,
-    const v8_inspector::V8StackTraceId& stack_id) {
+    BlinkTransferableMessage message,
+    WorkerThread* worker_thread) {
   WorkerGlobalScope* global_scope =
       ToWorkerGlobalScope(worker_thread->GlobalScope());
   MessagePortArray* ports =
-      MessagePort::EntanglePorts(*global_scope, std::move(channels));
+      MessagePort::EntanglePorts(*global_scope, std::move(message.ports));
 
   ThreadDebugger* debugger = ThreadDebugger::From(worker_thread->GetIsolate());
-  debugger->ExternalAsyncTaskStarted(stack_id);
-  global_scope->DispatchEvent(*MessageEvent::Create(ports, std::move(message)));
-  debugger->ExternalAsyncTaskFinished(stack_id);
+  debugger->ExternalAsyncTaskStarted(message.sender_stack_trace_id);
+  global_scope->DispatchEvent(
+      *MessageEvent::Create(ports, std::move(message.message)));
+  debugger->ExternalAsyncTaskFinished(message.sender_stack_trace_id);
 }
 
 void DedicatedWorkerObjectProxy::ProcessUnhandledException(

third_party/blink/renderer/core/workers/dedicated_worker_object_proxy.h

@@ -35,15 +35,12 @@
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
 #include "third_party/blink/renderer/core/core_export.h"
+#include "third_party/blink/renderer/core/messaging/blink_transferable_message.h"
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/core/workers/threaded_object_proxy_base.h"
 #include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 
-namespace v8_inspector {
-struct V8StackTraceId;
-}  // namespace v8_inspector
-
 namespace blink {
 
 class DedicatedWorkerMessagingProxy;
@@ -63,14 +60,9 @@ class CORE_EXPORT DedicatedWorkerObjectProxy : public ThreadedObjectProxyBase {
       ParentExecutionContextTaskRunners*);
   ~DedicatedWorkerObjectProxy() override;
 
-  void PostMessageToWorkerObject(scoped_refptr<SerializedScriptValue>,
-                                 Vector<MessagePortChannel>,
-                                 const v8_inspector::V8StackTraceId&);
+  void PostMessageToWorkerObject(BlinkTransferableMessage);
   void ProcessUnhandledException(int exception_id, WorkerThread*);
-  void ProcessMessageFromWorkerObject(scoped_refptr<SerializedScriptValue>,
-                                      Vector<MessagePortChannel>,
-                                      WorkerThread*,
-                                      const v8_inspector::V8StackTraceId&);
+  void ProcessMessageFromWorkerObject(BlinkTransferableMessage, WorkerThread*);
 
   // ThreadedObjectProxyBase overrides.
   void ReportException(const String& error_message,

third_party/blink/renderer/core/workers/dedicated_worker_test.cc

@@ -177,9 +177,8 @@ class DedicatedWorkerTest : public PageTestBase {
   }
 
   void DispatchMessageEvent() {
-    WorkerMessagingProxy()->PostMessageToWorkerGlobalScope(
-        nullptr /* message */, Vector<MessagePortChannel>(),
-        v8_inspector::V8StackTraceId());
+    BlinkTransferableMessage message;
+    WorkerMessagingProxy()->PostMessageToWorkerGlobalScope(std::move(message));
   }
 
   DedicatedWorkerMessagingProxyForTest* WorkerMessagingProxy() {