Reformat comments in core/html/parser

third_party/WebKit/Source/core/html/parser/HTMLConstructionSite.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 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
@@ skipping 166 matching lines @@
   if (task.operation == HTMLConstructionSiteTask::Reparent)
     return executeReparentTask(task);
 
   if (task.operation == HTMLConstructionSiteTask::TakeAllChildren)
     return executeTakeAllChildrenTask(task);
 
   ASSERT_NOT_REACHED();
 }
 
 // This is only needed for TextDocuments where we might have text nodes
-// approaching the default length limit (~64k) and we don't want to
-// break a text node in the middle of a combining character.
+// approaching the default length limit (~64k) and we don't want to break a text
+// node in the middle of a combining character.
 static unsigned findBreakIndexBetween(const StringBuilder& string,
                                       unsigned currentPosition,
                                       unsigned proposedBreakIndex) {
   ASSERT(currentPosition < proposedBreakIndex);
   ASSERT(proposedBreakIndex <= string.length());
   // The end of the string is always a valid break.
   if (proposedBreakIndex == string.length())
     return proposedBreakIndex;
 
-  // Latin-1 does not have breakable boundaries. If we ever moved to a differnet 8-bit encoding this could be wrong.
+  // Latin-1 does not have breakable boundaries. If we ever moved to a different
+  // 8-bit encoding this could be wrong.
   if (string.is8Bit())
     return proposedBreakIndex;
 
   const UChar* breakSearchCharacters = string.characters16() + currentPosition;
-  // We need at least two characters look-ahead to account for UTF-16 surrogates, but can't search off the end of the buffer!
+  // We need at least two characters look-ahead to account for UTF-16
+  // surrogates, but can't search off the end of the buffer!
   unsigned breakSearchLength =
       std::min(proposedBreakIndex - currentPosition + 2,
                string.length() - currentPosition);
   NonSharedCharacterBreakIterator it(breakSearchCharacters, breakSearchLength);
 
   if (it.isBreak(proposedBreakIndex - currentPosition))
     return proposedBreakIndex;
 
   int adjustedBreakIndexInSubstring =
       it.preceding(proposedBreakIndex - currentPosition);
   if (adjustedBreakIndexInSubstring > 0)
     return currentPosition + adjustedBreakIndexInSubstring;
   // We failed to find a breakable point, let the caller figure out what to do.
   return 0;
 }
 
 static String atomizeIfAllWhitespace(const String& string,
                                      WhitespaceMode whitespaceMode) {
-  // Strings composed entirely of whitespace are likely to be repeated.
-  // Turn them into AtomicString so we share a single string for each.
+  // Strings composed entirely of whitespace are likely to be repeated. Turn
+  // them into AtomicString so we share a single string for each.
   if (whitespaceMode == AllWhitespace ||
       (whitespaceMode == WhitespaceUnknown && isAllWhitespace(string)))
     return AtomicString(string).getString();
   return string;
 }
 
 void HTMLConstructionSite::flushPendingText(FlushMode mode) {
   if (m_pendingText.isEmpty())
     return;
 
   if (mode == FlushIfAtTextLimit &&
       !shouldUseLengthLimit(*m_pendingText.parent))
     return;
 
   PendingText pendingText;
-  // Hold onto the current pending text on the stack so that queueTask doesn't recurse infinitely.
+  // Hold onto the current pending text on the stack so that queueTask doesn't
+  // recurse infinitely.
   m_pendingText.swap(pendingText);
   ASSERT(m_pendingText.isEmpty());
 
-  // Splitting text nodes into smaller chunks contradicts HTML5 spec, but is necessary
-  // for performance, see: https://bugs.webkit.org/show_bug.cgi?id=55898
+  // Splitting text nodes into smaller chunks contradicts HTML5 spec, but is
+  // necessary for performance, see:
+  // https://bugs.webkit.org/show_bug.cgi?id=55898
   unsigned lengthLimit = textLengthLimitForContainer(*pendingText.parent);
 
   unsigned currentPosition = 0;
   const StringBuilder& string = pendingText.stringBuilder;
   while (currentPosition < string.length()) {
     unsigned proposedBreakIndex =
         std::min(currentPosition + lengthLimit, string.length());
     unsigned breakIndex =
         findBreakIndexBetween(string, currentPosition, proposedBreakIndex);
     ASSERT(breakIndex <= string.length());
@@ skipping 32 matching lines @@
   HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
   task.parent = parent;
   task.child = child;
   task.selfClosing = selfClosing;
 
   if (shouldFosterParent()) {
     fosterParent(task.child);
     return;
   }
 
-  // Add as a sibling of the parent if we have reached the maximum depth allowed.
+  // Add as a sibling of the parent if we have reached the maximum depth
+  // allowed.
   if (m_openElements.stackDepth() > maximumHTMLParserDOMTreeDepth &&
       task.parent->parentNode())
     task.parent = task.parent->parentNode();
 
   ASSERT(task.parent);
   queueTask(task);
 }
 
 void HTMLConstructionSite::executeQueuedTasks() {
-  // This has no affect on pendingText, and we may have pendingText
-  // remaining after executing all other queued tasks.
+  // This has no affect on pendingText, and we may have pendingText remaining
+  // after executing all other queued tasks.
   const size_t size = m_taskQueue.size();
   if (!size)
     return;
 
-  // Copy the task queue into a local variable in case executeTask
-  // re-enters the parser.
+  // Copy the task queue into a local variable in case executeTask re-enters the
+  // parser.
   TaskQueue queue;
   queue.swap(m_taskQueue);
 
   for (size_t i = 0; i < size; ++i)
     executeTask(queue[i]);
 
   // We might be detached now.
 }
 
 HTMLConstructionSite::HTMLConstructionSite(
@@ skipping 19 matching lines @@
   DCHECK(!m_form);
 
   m_attachmentRoot = fragment;
   m_isParsingFragment = true;
 
   if (!contextElement->document().isTemplateDocument())
     m_form = Traversal<HTMLFormElement>::firstAncestorOrSelf(*contextElement);
 }
 
 HTMLConstructionSite::~HTMLConstructionSite() {
-  // Depending on why we're being destroyed it might be OK
-  // to forget queued tasks, but currently we don't expect to.
+  // Depending on why we're being destroyed it might be OK to forget queued
+  // tasks, but currently we don't expect to.
   ASSERT(m_taskQueue.isEmpty());
-  // Currently we assume that text will never be the last token in the
-  // document and that we'll always queue some additional task to cause it to flush.
+  // Currently we assume that text will never be the last token in the document
+  // and that we'll always queue some additional task to cause it to flush.
   ASSERT(m_pendingText.isEmpty());
 }
 
 DEFINE_TRACE(HTMLConstructionSite) {
   visitor->trace(m_document);
   visitor->trace(m_attachmentRoot);
   visitor->trace(m_head);
   visitor->trace(m_form);
   visitor->trace(m_openElements);
   visitor->trace(m_activeFormattingElements);
   visitor->trace(m_taskQueue);
   visitor->trace(m_pendingText);
 }
 
 void HTMLConstructionSite::detach() {
-  // FIXME: We'd like to ASSERT here that we're canceling and not just discarding
-  // text that really should have made it into the DOM earlier, but there
-  // doesn't seem to be a nice way to do that.
+  // FIXME: We'd like to ASSERT here that we're canceling and not just
+  // discarding text that really should have made it into the DOM earlier, but
+  // there doesn't seem to be a nice way to do that.
   m_pendingText.discard();
   m_document = nullptr;
   m_attachmentRoot = nullptr;
 }
 
 HTMLFormElement* HTMLConstructionSite::takeForm() {
   return m_form.release();
 }
 
 void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(
@@ skipping 47 matching lines @@
     Document::CompatibilityMode mode) {
   m_inQuirksMode = (mode == Document::QuirksMode);
   m_document->setCompatibilityMode(mode);
 }
 
 void HTMLConstructionSite::setCompatibilityModeFromDoctype(
     const String& name,
     const String& publicId,
     const String& systemId) {
   // There are three possible compatibility modes:
-  // Quirks - quirks mode emulates WinIE and NS4. CSS parsing is also relaxed in this mode, e.g., unit types can
-  // be omitted from numbers.
-  // Limited Quirks - This mode is identical to no-quirks mode except for its treatment of line-height in the inline box model.
-  // No Quirks - no quirks apply. Web pages will obey the specifications to the letter.
+  // Quirks - quirks mode emulates WinIE and NS4. CSS parsing is also relaxed in
+  // this mode, e.g., unit types can be omitted from numbers.
+  // Limited Quirks - This mode is identical to no-quirks mode except for its
+  // treatment of line-height in the inline box model.
+  // No Quirks - no quirks apply. Web pages will obey the specifications to the
+  // letter.
 
   // Check for Quirks Mode.
   if (name != "html" ||
       publicId.startsWith("+//Silmaril//dtd html Pro v0r11 19970101//",
                           TextCaseInsensitive) ||
       publicId.startsWith(
           "-//AdvaSoft Ltd//DTD HTML 3.0 asWedit + extensions//",
           TextCaseInsensitive) ||
       publicId.startsWith("-//AS//DTD HTML 3.0 asWedit + extensions//",
                           TextCaseInsensitive) ||
@@ skipping 128 matching lines @@
   setCompatibilityMode(Document::NoQuirksMode);
 }
 
 void HTMLConstructionSite::processEndOfFile() {
   ASSERT(currentNode());
   flush(FlushAlways);
   openElements()->popAll();
 }
 
 void HTMLConstructionSite::finishedParsing() {
-  // We shouldn't have any queued tasks but we might have pending text which we need to promote to tasks and execute.
+  // We shouldn't have any queued tasks but we might have pending text which we
+  // need to promote to tasks and execute.
   ASSERT(m_taskQueue.isEmpty());
   flush(FlushAlways);
   m_document->finishedParsing();
 }
 
 void HTMLConstructionSite::insertDoctype(AtomicHTMLToken* token) {
   ASSERT(token->type() == HTMLToken::DOCTYPE);
 
   const String& publicId =
       StringImpl::create8BitIfPossible(token->publicIdentifier());
   const String& systemId =
       StringImpl::create8BitIfPossible(token->systemIdentifier());
   DocumentType* doctype =
       DocumentType::create(m_document, token->name(), publicId, systemId);
   attachLater(m_attachmentRoot, doctype);
 
-  // DOCTYPE nodes are only processed when parsing fragments w/o contextElements, which
-  // never occurs.  However, if we ever chose to support such, this code is subtly wrong,
-  // because context-less fragments can determine their own quirks mode, and thus change
-  // parsing rules (like <p> inside <table>).  For now we ASSERT that we never hit this code
-  // in a fragment, as changing the owning document's compatibility mode would be wrong.
+  // DOCTYPE nodes are only processed when parsing fragments w/o
+  // contextElements, which never occurs.  However, if we ever chose to support
+  // such, this code is subtly wrong, because context-less fragments can
+  // determine their own quirks mode, and thus change parsing rules (like <p>
+  // inside <table>).  For now we ASSERT that we never hit this code in a
+  // fragment, as changing the owning document's compatibility mode would be
+  // wrong.
   ASSERT(!m_isParsingFragment);
   if (m_isParsingFragment)
     return;
 
   if (token->forceQuirks())
     setCompatibilityMode(Document::QuirksMode);
   else {
     setCompatibilityModeFromDoctype(token->name(), publicId, systemId);
   }
 }
@@ skipping 66 matching lines @@
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#the-stack-of-open-elements
   // Possible active formatting elements include:
   // a, b, big, code, em, font, i, nobr, s, small, strike, strong, tt, and u.
   insertHTMLElement(token);
   m_activeFormattingElements.append(currentElementRecord()->stackItem());
 }
 
 void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken* token) {
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#already-started
   // http://html5.org/specs/dom-parsing.html#dom-range-createcontextualfragment
-  // For createContextualFragment, the specifications say to mark it parser-inserted and already-started and later unmark them.
-  // However, we short circuit that logic to avoid the subtree traversal to find script elements since scripts can never see
-  // those flags or effects thereof.
+  // For createContextualFragment, the specifications say to mark it
+  // parser-inserted and already-started and later unmark them. However, we
+  // short circuit that logic to avoid the subtree traversal to find script
+  // elements since scripts can never see those flags or effects thereof.
   const bool parserInserted =
       m_parserContentPolicy != AllowScriptingContentAndDoNotMarkAlreadyStarted;
   const bool alreadyStarted = m_isParsingFragment && parserInserted;
   // TODO(csharrison): This logic only works if the tokenizer/parser was not
   // blocked waiting for scripts when the element was inserted. This usually
-  // fails for instance, on second document.write if a script writes twice in
-  // a row. To fix this, the parser might have to keep track of raw string
+  // fails for instance, on second document.write if a script writes twice in a
+  // row. To fix this, the parser might have to keep track of raw string
   // position.
-  // TODO(csharrison): Refactor this so that the bools that are passed in are
-  // packed in a bitfield from an enum class.
+  // TODO(csharrison): Refactor this so that the bools that are passed
+  // in are packed in a bitfield from an enum class.
   const bool createdDuringDocumentWrite =
       ownerDocumentForCurrentNode().isInDocumentWrite();
   HTMLScriptElement* element =
       HTMLScriptElement::create(ownerDocumentForCurrentNode(), parserInserted,
                                 alreadyStarted, createdDuringDocumentWrite);
   setAttributes(element, token, m_parserContentPolicy);
   if (scriptingContentIsAllowed(m_parserContentPolicy))
     attachLater(currentNode(), element);
   m_openElements.push(HTMLStackItem::create(element, token));
 }
 
 void HTMLConstructionSite::insertForeignElement(
     AtomicHTMLToken* token,
     const AtomicString& namespaceURI) {
   ASSERT(token->type() == HTMLToken::StartTag);
-  DVLOG(1)
-      << "Not implemented.";  // parseError when xmlns or xmlns:xlink are wrong.
+  // parseError when xmlns or xmlns:xlink are wrong.
+  DVLOG(1) << "Not implemented.";
 
   Element* element = createElement(token, namespaceURI);
   if (scriptingContentIsAllowed(m_parserContentPolicy) ||
       !toScriptLoaderIfPossible(element))
     attachLater(currentNode(), element, token->selfClosing());
   if (!token->selfClosing())
     m_openElements.push(HTMLStackItem::create(element, token, namespaceURI));
 }
 
 void HTMLConstructionSite::insertTextNode(const String& string,
                                           WhitespaceMode whitespaceMode) {
   HTMLConstructionSiteTask dummyTask(HTMLConstructionSiteTask::Insert);
   dummyTask.parent = currentNode();
 
   if (shouldFosterParent())
     findFosterSite(dummyTask);
 
   // FIXME: This probably doesn't need to be done both here and in insert(Task).
   if (isHTMLTemplateElement(*dummyTask.parent))
     dummyTask.parent = toHTMLTemplateElement(dummyTask.parent.get())->content();
 
-  // Unclear when parent != case occurs. Somehow we insert text into two separate nodes while processing the same Token.
-  // The nextChild != dummy.nextChild case occurs whenever foster parenting happened and we hit a new text node "<table>a</table>b"
-  // In either case we have to flush the pending text into the task queue before making more.
+  // Unclear when parent != case occurs. Somehow we insert text into two
+  // separate nodes while processing the same Token. The nextChild !=
+  // dummy.nextChild case occurs whenever foster parenting happened and we hit a
+  // new text node "<table>a</table>b" In either case we have to flush the
+  // pending text into the task queue before making more.
   if (!m_pendingText.isEmpty() &&
       (m_pendingText.parent != dummyTask.parent ||
        m_pendingText.nextChild != dummyTask.nextChild))
     flushPendingText(FlushAlways);
   m_pendingText.append(dummyTask.parent, dummyTask.nextChild, string,
                        whitespaceMode);
 }
 
 void HTMLConstructionSite::reparent(HTMLElementStack::ElementRecord* newParent,
                                     HTMLElementStack::ElementRecord* child) {
@@ skipping 74 matching lines @@
   const Attribute* isAttribute = token->getAttributeItem(HTMLNames::isAttr);
   const AtomicString& name = isAttribute ? isAttribute->value() : localName;
   CustomElementDescriptor descriptor(name, localName);
 
   // 4.-6.
   return registry->definitionFor(descriptor);
 }
 
 // "create an element for a token"
 // https://html.spec.whatwg.org/#create-an-element-for-the-token
-// TODO(dominicc): When form association is separate from creation,
-// unify this with foreign element creation. Add a namespace parameter
-// and check for HTML namespace to lookupCustomElementDefinition.
+// TODO(dominicc): When form association is separate from creation, unify this
+// with foreign element creation. Add a namespace parameter and check for HTML
+// namespace to lookupCustomElementDefinition.
 HTMLElement* HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token) {
   // "1. Let document be intended parent's node document."
   Document& document = ownerDocumentForCurrentNode();
 
-  // Only associate the element with the current form if we're creating the new element
-  // in a document with a browsing context (rather than in <template> contents).
+  // Only associate the element with the current form if we're creating the new
+  // element in a document with a browsing context (rather than in <template>
+  // contents).
   // TODO(dominicc): Change form to happen after element creation when
   // implementing customized built-in elements.
   HTMLFormElement* form = document.frame() ? m_form.get() : nullptr;
 
   // "2. Let local name be the tag name of the token."
   // "3. Let is be the value of the "is" attribute in the giev token ..." etc.
   // "4. Let definition be the result of looking up a custom element ..." etc.
   CustomElementDefinition* definition =
       m_isParsingFragment ? nullptr
                           : lookUpCustomElementDefinition(document, token);
   // "5. If definition is non-null and the parser was not originally created
   // for the HTML fragment parsing algorithm, then let will execute script
   // be true."
   bool willExecuteScript = definition && !m_isParsingFragment;
 
   HTMLElement* element;
 
   if (willExecuteScript) {
     // "6.1 Increment the document's throw-on-dynamic-insertion counter."
     ThrowOnDynamicMarkupInsertionCountIncrementer
         throwOnDynamicMarkupInsertions(&document);
 
     // "6.2 If the JavaScript execution context stack is empty,
     // then perform a microtask checkpoint."
 
-    // TODO(dominicc): This is the way the Blink HTML parser
-    // performs checkpoints, but note the spec is different--it
-    // talks about the JavaScript stack, not the script nesting
-    // level.
+    // TODO(dominicc): This is the way the Blink HTML parser performs
+    // checkpoints, but note the spec is different--it talks about the
+    // JavaScript stack, not the script nesting level.
     if (0u == m_reentryPermit->scriptNestingLevel())
       Microtask::performCheckpoint(V8PerIsolateData::mainThreadIsolate());
 
     // "6.3 Push a new element queue onto the custom element
     // reactions stack."
     CEReactionsScope reactions;
 
     // 7.
     QualifiedName elementQName(nullAtom, token->name(),
                                HTMLNames::xhtmlNamespaceURI);
     element = definition->createElementSync(document, elementQName);
 
-    // "8. Append each attribute in the given token to element."
-    // We don't use setAttributes here because the custom element
-    // constructor may have manipulated attributes.
+    // "8. Append each attribute in the given token to element." We don't use
+    // setAttributes here because the custom element constructor may have
+    // manipulated attributes.
     for (const auto& attribute : token->attributes())
       element->setAttribute(attribute.name(), attribute.value());
 
-    // "9. If will execute script is true, then ..." etc. The
-    // CEReactionsScope and ThrowOnDynamicMarkupInsertionCountIncrementer
-    // destructors implement steps 9.1-3.
+    // "9. If will execute script is true, then ..." etc. The CEReactionsScope
+    // and ThrowOnDynamicMarkupInsertionCountIncrementer destructors implement
+    // steps 9.1-3.
   } else {
-    // FIXME: This can't use
-    // HTMLConstructionSite::createElement because we have to
-    // pass the current form element. We should rework form
-    // association to occur after construction to allow better
-    // code sharing here.
+    // FIXME: This can't use HTMLConstructionSite::createElement because we have
+    // to pass the current form element. We should rework form association to
+    // occur after construction to allow better code sharing here.
     element = HTMLElementFactory::createHTMLElement(
         token->name(), document, form, getCreateElementFlags());
-    // Definition for the created element does not exist here and
-    // it cannot be custom or failed.
+    // Definition for the created element does not exist here and it cannot be
+    // custom or failed.
     DCHECK_NE(element->getCustomElementState(), CustomElementState::Custom);
     DCHECK_NE(element->getCustomElementState(), CustomElementState::Failed);
 
     // "8. Append each attribute in the given token to element."
     setAttributes(element, token, m_parserContentPolicy);
   }
 
-  // TODO(dominicc): Implement steps 10-12 when customized built-in
-  // elements are implemented.
+  // TODO(dominicc): Implement steps 10-12 when customized built-in elements are
+  // implemented.
 
   return element;
 }
 
 HTMLStackItem* HTMLConstructionSite::createElementFromSavedToken(
     HTMLStackItem* item) {
   Element* element;
   // NOTE: Moving from item -> token -> item copies the Attribute vector twice!
   AtomicHTMLToken fakeToken(HTMLToken::StartTag, item->localName(),
                             item->attributes());
@@ skipping 50 matching lines @@
 
 void HTMLConstructionSite::generateImpliedEndTags() {
   while (hasImpliedEndTag(currentStackItem()))
     m_openElements.pop();
 }
 
 bool HTMLConstructionSite::inQuirksMode() {
   return m_inQuirksMode;
 }
 
-// Adjusts |task| to match the "adjusted insertion location" determined by the foster parenting algorithm,
-// laid out as the substeps of step 2 of https://html.spec.whatwg.org/#appropriate-place-for-inserting-a-node
+// Adjusts |task| to match the "adjusted insertion location" determined by the
+// foster parenting algorithm, laid out as the substeps of step 2 of
+// https://html.spec.whatwg.org/#appropriate-place-for-inserting-a-node
 void HTMLConstructionSite::findFosterSite(HTMLConstructionSiteTask& task) {
   // 2.1
   HTMLElementStack::ElementRecord* lastTemplate =
       m_openElements.topmost(templateTag.localName());
 
   // 2.2
   HTMLElementStack::ElementRecord* lastTable =
       m_openElements.topmost(tableTag.localName());
 
   // 2.3
@@ skipping 33 matching lines @@
   ASSERT(task.parent);
   queueTask(task);
 }
 
 DEFINE_TRACE(HTMLConstructionSite::PendingText) {
   visitor->trace(parent);
   visitor->trace(nextChild);
 }
 
 }  // namespace blink