HTML MessagePort as mojo::MessagePipeHandle

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 58 matching lines @@
 
   // Make sure we aren't connected to any of the passed-in ports.
   for (unsigned i = 0; i < ports.size(); ++i) {
     if (ports[i] == this) {
       exceptionState.throwDOMException(
           DataCloneError,
           "Port at index " + String::number(i) + " contains the source port.");
       return;
     }
   }
-  std::unique_ptr<MessagePortChannelArray> channels =
+  MessagePortChannelArray channels =
       MessagePort::disentanglePorts(scriptState->getExecutionContext(), ports,
                                     exceptionState);
   if (exceptionState.hadException())
     return;
 
   WebString messageString = message->toWireString();
-  std::unique_ptr<WebMessagePortChannelArray> webChannels =
+  WebMessagePortChannelArray webChannels =
       toWebMessagePortChannelArray(std::move(channels));
-  m_entangledChannel->postMessage(messageString, webChannels.release());
+  m_entangledChannel->postMessage(messageString, std::move(webChannels));
 }
 
 // static
-std::unique_ptr<WebMessagePortChannelArray>
-MessagePort::toWebMessagePortChannelArray(
-    std::unique_ptr<MessagePortChannelArray> channels) {
-  std::unique_ptr<WebMessagePortChannelArray> webChannels;
-  if (channels && channels->size()) {
-    webChannels =
-        WTF::wrapUnique(new WebMessagePortChannelArray(channels->size()));
-    for (size_t i = 0; i < channels->size(); ++i)
-      (*webChannels)[i] = (*channels)[i].release();
-  }
+WebMessagePortChannelArray MessagePort::toWebMessagePortChannelArray(
+    MessagePortChannelArray channels) {
+  WebMessagePortChannelArray webChannels(channels.size());
+  for (size_t i = 0; i < channels.size(); ++i)
+    webChannels[i] = std::move(channels[i]);
   return webChannels;
 }
 
 // static
 MessagePortArray* MessagePort::toMessagePortArray(
     ExecutionContext* context,
-    const WebMessagePortChannelArray& webChannels) {
-  std::unique_ptr<MessagePortChannelArray> channels =
-      WTF::wrapUnique(new MessagePortChannelArray(webChannels.size()));
+    WebMessagePortChannelArray webChannels) {
+  MessagePortChannelArray channels(webChannels.size());
   for (size_t i = 0; i < webChannels.size(); ++i)
-    (*channels)[i] = WebMessagePortChannelUniquePtr(webChannels[i]);
+    channels[i] = std::move(webChannels[i]);
   return MessagePort::entanglePorts(*context, std::move(channels));
 }
 
 WebMessagePortChannelUniquePtr MessagePort::disentangle() {
   DCHECK(m_entangledChannel);
   m_entangledChannel->setClient(nullptr);
   return std::move(m_entangledChannel);
 }
 
 // Invoked to notify us that there are messages available for this port.
@@ skipping 35 matching lines @@
   DCHECK(!m_entangledChannel);
   DCHECK(getExecutionContext());
 
   m_entangledChannel = std::move(remote);
 }
 
 const AtomicString& MessagePort::interfaceName() const {
   return EventTargetNames::MessagePort;
 }
 
-static bool tryGetMessageFrom(
-    WebMessagePortChannel& webChannel,
-    RefPtr<SerializedScriptValue>& message,
-    std::unique_ptr<MessagePortChannelArray>& channels) {
+static bool tryGetMessageFrom(WebMessagePortChannel& webChannel,
+                              RefPtr<SerializedScriptValue>& message,
+                              MessagePortChannelArray& channels) {
   WebString messageString;
   WebMessagePortChannelArray webChannels;
   if (!webChannel.tryGetMessage(&messageString, webChannels))
     return false;
 
   if (webChannels.size()) {
-    channels = WTF::wrapUnique(new MessagePortChannelArray(webChannels.size()));
+    channels.resize(webChannels.size());
     for (size_t i = 0; i < webChannels.size(); ++i)
-      (*channels)[i] = WebMessagePortChannelUniquePtr(webChannels[i]);
+      channels[i] = std::move(webChannels[i]);
   }
   message = SerializedScriptValue::create(messageString);
   return true;
 }
 
-bool MessagePort::tryGetMessage(
-    RefPtr<SerializedScriptValue>& message,
-    std::unique_ptr<MessagePortChannelArray>& channels) {
+bool MessagePort::tryGetMessage(RefPtr<SerializedScriptValue>& message,
+                                MessagePortChannelArray& channels) {
   if (!m_entangledChannel)
     return false;
   return tryGetMessageFrom(*m_entangledChannel, message, channels);
 }
 
 void MessagePort::dispatchMessages() {
   // 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
     // the port is still open before each dispatch.
     if (m_closed)
       break;
 
     // WorkerGlobalScope::close() in Worker onmessage handler should prevent
     // the next message from dispatching.
     if (getExecutionContext()->isWorkerGlobalScope() &&
         toWorkerGlobalScope(getExecutionContext())->isClosing()) {
       break;
     }
 
     RefPtr<SerializedScriptValue> message;
-    std::unique_ptr<MessagePortChannelArray> channels;
+    MessagePortChannelArray channels;
     if (!tryGetMessage(message, channels))
       break;
 
     MessagePortArray* ports =
         MessagePort::entanglePorts(*getExecutionContext(), std::move(channels));
     Event* evt = MessageEvent::create(ports, std::move(message));
 
     dispatchEvent(evt);
   }
 }
 
 bool MessagePort::hasPendingActivity() const {
   // The spec says that entangled message ports should always be treated as if
   // they have a strong reference.
   // We'll also stipulate that the queue needs to be open (if the app drops its
   // reference to the port before start()-ing it, then it's not really entangled
   // as it's unreachable).
   return m_started && isEntangled();
 }
 
-std::unique_ptr<MessagePortChannelArray> MessagePort::disentanglePorts(
+MessagePortChannelArray MessagePort::disentanglePorts(
     ExecutionContext* context,
     const MessagePortArray& ports,
     ExceptionState& exceptionState) {
   if (!ports.size())
-    return nullptr;
+    return MessagePortChannelArray();
 
   HeapHashSet<Member<MessagePort>> visited;
 
   // Walk the incoming array - if there are any duplicate ports, or null ports
   // or cloned ports, throw an error (per section 8.3.3 of the HTML5 spec).
   for (unsigned i = 0; i < ports.size(); ++i) {
     MessagePort* port = ports[i];
     if (!port || port->isNeutered() || visited.contains(port)) {
       String type;
       if (!port)
         type = "null";
       else if (port->isNeutered())
         type = "already neutered";
       else
         type = "a duplicate";
       exceptionState.throwDOMException(
           DataCloneError,
           "Port at index " + String::number(i) + " is " + type + ".");
-      return nullptr;
+      return MessagePortChannelArray();
     }
     visited.insert(port);
   }
 
   UseCounter::count(context, UseCounter::MessagePortsTransferred);
 
   // Passed-in ports passed validity checks, so we can disentangle them.
-  std::unique_ptr<MessagePortChannelArray> portArray =
-      WTF::wrapUnique(new MessagePortChannelArray(ports.size()));
+  MessagePortChannelArray portArray(ports.size());
   for (unsigned i = 0; i < ports.size(); ++i)
-    (*portArray)[i] = ports[i]->disentangle();
+    portArray[i] = ports[i]->disentangle();
   return portArray;
 }
 
-MessagePortArray* MessagePort::entanglePorts(
-    ExecutionContext& context,
-    std::unique_ptr<MessagePortChannelArray> channels) {
+MessagePortArray* MessagePort::entanglePorts(ExecutionContext& context,
+                                             MessagePortChannelArray channels) {
   // https://html.spec.whatwg.org/multipage/comms.html#message-ports
   // |ports| should be an empty array, not null even when there is no ports.
-  if (!channels || !channels->size())
-    return new MessagePortArray;
-
-  MessagePortArray* portArray = new MessagePortArray(channels->size());
-  for (unsigned i = 0; i < channels->size(); ++i) {
+  MessagePortArray* portArray = new MessagePortArray(channels.size());
+  for (unsigned i = 0; i < channels.size(); ++i) {
     MessagePort* port = MessagePort::create(context);
-    port->entangle(std::move((*channels)[i]));
+    port->entangle(std::move(channels[i]));
     (*portArray)[i] = port;
   }
   return portArray;
 }
 
 DEFINE_TRACE(MessagePort) {
   ContextLifecycleObserver::trace(visitor);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink