Reformat comments in core/html/parser

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

 /*
  * 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 42 matching lines @@
   explicit HTMLConstructionSiteTask(Operation op)
       : operation(op), selfClosing(false) {}
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(parent);
     visitor->trace(nextChild);
     visitor->trace(child);
   }
 
   ContainerNode* oldParent() {
-    // It's sort of ugly, but we store the |oldParent| in the |child| field
-    // of the task so that we don't bloat the HTMLConstructionSiteTask
-    // object in the common case of the Insert operation.
+    // It's sort of ugly, but we store the |oldParent| in the |child| field of
+    // the task so that we don't bloat the HTMLConstructionSiteTask object in
+    // the common case of the Insert operation.
     return toContainerNode(child.get());
   }
 
   Operation operation;
   Member<ContainerNode> parent;
   Member<Node> nextChild;
   Member<Node> child;
   bool selfClosing;
 };
 
 }  // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
     blink::HTMLConstructionSiteTask);
 
 namespace blink {
 
-// Note: These are intentionally ordered so that when we concatonate
-// strings and whitespaces the resulting whitespace is ws = min(ws1, ws2).
+// Note: These are intentionally ordered so that when we concatonate strings and
+// whitespaces the resulting whitespace is ws = min(ws1, ws2).
 enum WhitespaceMode {
   WhitespaceUnknown,
   NotAllWhitespace,
   AllWhitespace,
 };
 
 enum FlushMode {
   // Flush pending text. Flush queued tasks.
   FlushAlways,
 
@@ skipping 20 matching lines @@
   DECLARE_TRACE();
 
   void initFragmentParsing(DocumentFragment*, Element* contextElement);
 
   void detach();
 
   // executeQueuedTasks empties the queue but does not flush pending text.
   // NOTE: Possible reentrancy via JavaScript execution.
   void executeQueuedTasks();
 
-  // flushPendingText turns pending text into queued Text insertions, but does not execute them.
+  // flushPendingText turns pending text into queued Text insertions, but does
+  // not execute them.
   void flushPendingText(FlushMode);
 
   // Called before every token in HTMLTreeBuilder::processToken, thus inlined:
   void flush(FlushMode mode) {
     if (!hasPendingTasks())
       return;
     flushPendingText(mode);
-    executeQueuedTasks();  // NOTE: Possible reentrancy via JavaScript execution.
+    // NOTE: Possible reentrancy via JavaScript execution.
+    executeQueuedTasks();
     ASSERT(mode == FlushIfAtTextLimit || !hasPendingTasks());
   }
 
   bool hasPendingTasks() {
     return !m_pendingText.isEmpty() || !m_taskQueue.isEmpty();
   }
 
   void setDefaultCompatibilityMode();
   void processEndOfFile();
   void finishedParsing();
@@ skipping 13 matching lines @@
   void insertForeignElement(AtomicHTMLToken*, const AtomicString& namespaceURI);
 
   void insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken*);
   void insertHTMLHtmlStartTagInBody(AtomicHTMLToken*);
   void insertHTMLBodyStartTagInBody(AtomicHTMLToken*);
 
   void reparent(HTMLElementStack::ElementRecord* newParent,
                 HTMLElementStack::ElementRecord* child);
   void reparent(HTMLElementStack::ElementRecord* newParent,
                 HTMLStackItem* child);
-  // insertAlreadyParsedChild assumes that |child| has already been parsed (i.e., we're just
-  // moving it around in the tree rather than parsing it for the first time). That means
-  // this function doesn't call beginParsingChildren / finishParsingChildren.
+  // insertAlreadyParsedChild assumes that |child| has already been parsed
+  // (i.e., we're just moving it around in the tree rather than parsing it for
+  // the first time). That means this function doesn't call beginParsingChildren
+  // / finishParsingChildren.
   void insertAlreadyParsedChild(HTMLStackItem* newParent,
                                 HTMLElementStack::ElementRecord* child);
   void takeAllChildren(HTMLStackItem* newParent,
                        HTMLElementStack::ElementRecord* oldParent);
 
   HTMLStackItem* createElementFromSavedToken(HTMLStackItem*);
 
   bool shouldFosterParent() const;
   void fosterParent(Node*);
 
@@ skipping 47 matching lines @@
     ~RedirectToFosterParentGuard() {
       m_tree.m_redirectAttachToFosterParent = m_wasRedirectingBefore;
     }
 
    private:
     HTMLConstructionSite& m_tree;
     bool m_wasRedirectingBefore;
   };
 
  private:
-  // In the common case, this queue will have only one task because most
-  // tokens produce only one DOM mutation.
+  // In the common case, this queue will have only one task because most tokens
+  // produce only one DOM mutation.
   typedef HeapVector<HTMLConstructionSiteTask, 1> TaskQueue;
 
   void setCompatibilityMode(Document::CompatibilityMode);
   void setCompatibilityModeFromDoctype(const String& name,
                                        const String& publicId,
                                        const String& systemId);
 
   void attachLater(ContainerNode* parent,
                    Node* child,
                    bool selfClosing = false);
@@ skipping 53 matching lines @@
       nextChild.swap(other.nextChild);
       stringBuilder.swap(other.stringBuilder);
     }
 
     void discard() {
       PendingText discardedText;
       swap(discardedText);
     }
 
     bool isEmpty() {
-      // When the stringbuilder is empty, the parent and whitespace should also be "empty".
+      // When the stringbuilder is empty, the parent and whitespace should also
+      // be "empty".
       ASSERT(stringBuilder.isEmpty() == !parent);
       ASSERT(!stringBuilder.isEmpty() || !nextChild);
       ASSERT(!stringBuilder.isEmpty() || (whitespaceMode == WhitespaceUnknown));
       return stringBuilder.isEmpty();
     }
 
     DECLARE_TRACE();
 
     Member<ContainerNode> parent;
     Member<Node> nextChild;
@@ skipping 10 matching lines @@
   // In the "in table" insertion mode, we sometimes get into a state where
   // "whenever a node would be inserted into the current node, it must instead
   // be foster parented."  This flag tracks whether we're in that state.
   bool m_redirectAttachToFosterParent;
 
   bool m_inQuirksMode;
 };
 
 }  // namespace blink
 
-#endif
+#endif  // HTMLConstructionSite_h