MessagePort: don't post repeated message dispatch tasks.

third_party/WebKit/Source/core/dom/MessagePort.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 21 matching lines @@
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/SerializedScriptValueFactory.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MessageEvent.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "public/platform/WebString.h"
-#include "wtf/Functional.h"
+#include "wtf/Atomics.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
 MessagePort* MessagePort::create(ExecutionContext& executionContext) {
   return new MessagePort(executionContext);
 }
 
 MessagePort::MessagePort(ExecutionContext& executionContext)
     : ContextLifecycleObserver(&executionContext),
+      m_pendingDispatchTask(0),
       m_started(false),
       m_closed(false) {}
 
 MessagePort::~MessagePort() {
   DCHECK(!m_started || !isEntangled());
 }
 
 void MessagePort::postMessage(ScriptState* scriptState,
                               PassRefPtr<SerializedScriptValue> message,
                               const MessagePortArray& ports,
@@ skipping 47 matching lines @@
   DCHECK(m_entangledChannel);
   m_entangledChannel->setClient(nullptr);
   return std::move(m_entangledChannel);
 }
 
 // Invoked to notify us that there are messages available for this port.
 // This code may be called from another thread, and so should not call any
 // non-threadsafe APIs (i.e. should not call into the entangled channel or
 // access mutable variables).
 void MessagePort::messageAvailable() {
+  // Don't post another task if there's an identical one pending.
+  if (atomicTestAndSetToOne(&m_pendingDispatchTask))

[dcheng, 2017/02/27 08:06:37]

It really feels like we should have a better way of doing this (since there were
no callers of this function before this CL), but maybe it's not a very common
situation.

[sof, 2017/02/27 08:21:37]

"this" == cross-thread prevention of task re-posts..? I haven't come across
anything similar in Blink, fwiw.

(Are we allowed to use std::atomic in WebKit/Source/, btw?)

+    return;
+
   DCHECK(getExecutionContext());
   // TODO(tzik): Use ParentThreadTaskRunners instead of ExecutionContext here to
   // avoid touching foreign thread GCed object.
   getExecutionContext()->postTask(
       TaskType::PostedMessage, BLINK_FROM_HERE,
       createCrossThreadTask(&MessagePort::dispatchMessages,
                             wrapCrossThreadWeakPersistent(this)));
 }
 
 void MessagePort::start() {
@@ skipping 46 matching lines @@
 }
 
 bool MessagePort::tryGetMessage(RefPtr<SerializedScriptValue>& message,
                                 MessagePortChannelArray& channels) {
   if (!m_entangledChannel)
     return false;
   return tryGetMessageFrom(*m_entangledChannel, message, channels);
 }
 
 void MessagePort::dispatchMessages() {
+  // Signal to |messageAvailable()| that there are no ongoing
+  // dispatches of messages. This can cause redundantly posted
+  // tasks, but safely avoids messages languishing.
+  releaseStore(&m_pendingDispatchTask, 0);
+
   // Messages for contexts that are not fully active get dispatched too, but
   // JSAbstractEventListener::handleEvent() doesn't call handlers for these.
   // The HTML5 spec specifies that any messages sent to a document that is not
   // fully active should be dropped, so this behavior is OK.
   if (!started())
     return;
 
   while (true) {
     // Because close() doesn't cancel any in flight calls to dispatchMessages(),
     // and can be triggered by the onmessage event handler, we need to check if
@@ skipping 80 matching lines @@
   }
   return portArray;
 }
 
 DEFINE_TRACE(MessagePort) {
   ContextLifecycleObserver::trace(visitor);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink