Reflow comments in core/dom/.

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 111 matching lines @@
   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.
-// 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).
+// 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() {
   DCHECK(getExecutionContext());
   getExecutionContext()->postTask(
       BLINK_FROM_HERE,
       createCrossThreadTask(&MessagePort::dispatchMessages,
                             wrapCrossThreadWeakPersistent(this)));
 }
 
 void MessagePort::start() {
   // Do nothing if we've been cloned or closed.
@@ skipping 47 matching lines @@
 
 bool MessagePort::tryGetMessage(
     RefPtr<SerializedScriptValue>& message,
     std::unique_ptr<MessagePortChannelArray>& channels) {
   if (!m_entangledChannel)
     return false;
   return tryGetMessageFrom(*m_entangledChannel, message, channels);
 }
 
 void MessagePort::dispatchMessages() {
-  // Because close() doesn't cancel any in flight calls to dispatchMessages() we need to check if the port is still open before dispatch.
+  // Because close() doesn't cancel any in flight calls to dispatchMessages() we
+  // need to check if the port is still open before dispatch.
   if (m_closed)
     return;
 
-  // 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.
+  // 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;
 
   RefPtr<SerializedScriptValue> message;
   std::unique_ptr<MessagePortChannelArray> channels;
   while (tryGetMessage(message, channels)) {
-    // close() in Worker onmessage handler should prevent next message from dispatching.
+    // close() in Worker onmessage handler should prevent next message from
+    // dispatching.
     if (getExecutionContext()->isWorkerGlobalScope() &&
         toWorkerGlobalScope(getExecutionContext())->isClosing())
       return;
 
     MessagePortArray* ports =
         MessagePort::entanglePorts(*getExecutionContext(), std::move(channels));
     Event* evt = MessageEvent::create(ports, message.release());
 
     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).
+  // 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(
     ExecutionContext* context,
     const MessagePortArray& ports,
     ExceptionState& exceptionState) {
   if (!ports.size())
     return nullptr;
 
   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).
+  // 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";
@@ skipping 31 matching lines @@
   }
   return portArray;
 }
 
 DEFINE_TRACE(MessagePort) {
   ActiveDOMObject::trace(visitor);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink