Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/Document.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
- * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All
+ * rights reserved.
+ * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 159 matching lines @@
 struct FocusParams;
 struct IconURL;
 
 using MouseEventWithHitTestResults =
     EventWithHitTestResults<PlatformMouseEvent>;
 using ExceptionCode = int;
 
 enum StyleResolverUpdateMode {
   // Discards the StyleResolver and rebuilds it.
   FullStyleUpdate,
-  // Attempts to use StyleInvalidationAnalysis to avoid discarding the entire StyleResolver.
+  // Attempts to use StyleInvalidationAnalysis to avoid discarding the entire
+  // StyleResolver.
   AnalyzedStyleUpdate
 };
 
 enum NodeListInvalidationType {
   DoNotInvalidateOnAttributeChanges = 0,
   InvalidateOnClassAttrChange,
   InvalidateOnIdNameAttrChange,
   InvalidateOnNameAttrChange,
   InvalidateOnForAttrChange,
   InvalidateForFormControls,
@@ skipping 533 matching lines @@
                       ExceptionState&) const;
 
   void didInsertText(Node*, unsigned offset, unsigned length);
   void didRemoveText(Node*, unsigned offset, unsigned length);
   void didMergeTextNodes(Text& oldNode, unsigned offset);
   void didSplitTextNode(Text& oldNode);
 
   void clearDOMWindow() { m_domWindow = nullptr; }
   LocalDOMWindow* domWindow() const { return m_domWindow; }
 
-  // Helper functions for forwarding LocalDOMWindow event related tasks to the LocalDOMWindow if it exists.
+  // Helper functions for forwarding LocalDOMWindow event related tasks to the
+  // LocalDOMWindow if it exists.
   void setWindowAttributeEventListener(const AtomicString& eventType,
                                        EventListener*);
   EventListener* getWindowAttributeEventListener(const AtomicString& eventType);
 
   static void registerEventFactory(std::unique_ptr<EventFactoryBase>);
   static Event* createEvent(ExecutionContext*,
                             const String& eventType,
                             ExceptionState&);
 
   // keep track of what types of event listeners are registered, so we don't
@@ skipping 74 matching lines @@
   // A: The two URLs are the same almost all the time.  However, if one
   //    document inherits the security context of another document, it
   //    inherits its cookieURL but not its URL.
   //
   const KURL& cookieURL() const { return m_cookieURL; }
   void setCookieURL(const KURL& url) { m_cookieURL = url; }
 
   const KURL firstPartyForCookies() const;
 
   // The following implements the rule from HTML 4 for what valid names are.
-  // To get this right for all the XML cases, we probably have to improve this or move it
-  // and make it sensitive to the type of document.
+  // To get this right for all the XML cases, we probably have to improve this
+  // or move it and make it sensitive to the type of document.
   static bool isValidName(const String&);
 
   // The following breaks a qualified name into a prefix and a local name.
   // It also does a validity check, and returns false if the qualified name
   // is invalid.  It also sets ExceptionCode when name is invalid.
   static bool parseQualifiedName(const AtomicString& qualifiedName,
                                  AtomicString& prefix,
                                  AtomicString& localName,
                                  ExceptionState&);
 
   // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
   static bool hasValidNamespaceForElements(const QualifiedName&);
   static bool hasValidNamespaceForAttributes(const QualifiedName&);
 
-  // "body element" as defined by HTML5 (https://html.spec.whatwg.org/multipage/dom.html#the-body-element-2).
+  // "body element" as defined by HTML5
+  // (https://html.spec.whatwg.org/multipage/dom.html#the-body-element-2).
   // That is, the first body or frameset child of the document element.
   HTMLElement* body() const;
 
-  // "HTML body element" as defined by CSSOM View spec (http://dev.w3.org/csswg/cssom-view/#the-html-body-element).
+  // "HTML body element" as defined by CSSOM View spec
+  // (http://dev.w3.org/csswg/cssom-view/#the-html-body-element).
   // That is, the first body child of the document element.
   HTMLBodyElement* firstBodyElement() const;
 
   void setBody(HTMLElement*, ExceptionState&);
   void willInsertBody();
 
   HTMLHeadElement* head() const;
 
-  // Decide which element is to define the viewport's overflow policy. If |rootStyle| is set, use
-  // that as the style for the root element, rather than obtaining it on our own. The reason for
-  // this is that style may not have been associated with the elements yet - in which case it may
-  // have been calculated on the fly (without associating it with the actual element) somewhere.
+  // Decide which element is to define the viewport's overflow policy. If
+  // |rootStyle| is set, use that as the style for the root element, rather than
+  // obtaining it on our own. The reason for this is that style may not have
+  // been associated with the elements yet - in which case it may have been
+  // calculated on the fly (without associating it with the actual element)
+  // somewhere.
   Element* viewportDefiningElement(
       const ComputedStyle* rootStyle = nullptr) const;
 
   DocumentMarkerController& markers() const { return *m_markers; }
 
   bool execCommand(const String& command,
                    bool showUI,
                    const String& value,
                    ExceptionState&);
   bool isRunningExecCommand() const { return m_isRunningExecCommand; }
@@ skipping 65 matching lines @@
 
   void setUseSecureKeyboardEntryWhenActive(bool);
   bool useSecureKeyboardEntryWhenActive() const;
 
   void updateFocusAppearanceSoon(SelectionBehaviorOnFocus);
   void cancelFocusAppearanceUpdate();
 
   bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
   void parseDNSPrefetchControlHeader(const String&);
 
-  // FIXME(crbug.com/305497): This should be removed once LocalDOMWindow is an ExecutionContext.
+  // FIXME(crbug.com/305497): This should be removed once LocalDOMWindow is an
+  // ExecutionContext.
   void postTask(const WebTraceLocation&,
                 std::unique_ptr<ExecutionContextTask>,
                 const String& taskNameForInstrumentation = emptyString())
       override;  // Executes the task on context's thread asynchronously.
   void postInspectorTask(const WebTraceLocation&,
                          std::unique_ptr<ExecutionContextTask>);
 
   void tasksWereSuspended() final;
   void tasksWereResumed() final;
   void suspendScheduledTasks() final;
@@ skipping 73 matching lines @@
   bool isJSExecutionForbidden() const final { return false; }
 
   bool containsValidityStyleRules() const {
     return m_containsValidityStyleRules;
   }
   void setContainsValidityStyleRules() { m_containsValidityStyleRules = true; }
 
   void enqueueResizeEvent();
   void enqueueScrollEventForNode(Node*);
   void enqueueAnimationFrameEvent(Event*);
-  // Only one event for a target/event type combination will be dispatched per frame.
+  // Only one event for a target/event type combination will be dispatched per
+  // frame.
   void enqueueUniqueAnimationFrameEvent(Event*);
   void enqueueMediaQueryChangeListeners(
       HeapVector<Member<MediaQueryListListener>>&);
   void enqueueVisualViewportScrollEvent();
   void enqueueVisualViewportResizeEvent();
 
   void dispatchEventsForPrinting();
 
   bool hasFullscreenSupplement() const { return m_hasFullscreenSupplement; }
   void setHasFullscreenSupplement() { m_hasFullscreenSupplement = true; }
 
   void exitPointerLock();
   Element* pointerLockElement() const;
 
-  // Used to allow element that loads data without going through a FrameLoader to delay the 'load' event.
+  // Used to allow element that loads data without going through a FrameLoader
+  // to delay the 'load' event.
   void incrementLoadEventDelayCount() { ++m_loadEventDelayCount; }
   void decrementLoadEventDelayCount();
   void checkLoadEventSoon();
   bool isDelayingLoadEvent();
   void loadPluginsSoon();
 
   Touch* createTouch(DOMWindow*,
                      EventTarget*,
                      int identifier,
                      double pageX,
@@ skipping 76 matching lines @@
     return *m_compositorPendingAnimations;
   }
 
   void addToTopLayer(Element*, const Element* before = nullptr);
   void removeFromTopLayer(Element*);
   const HeapVector<Member<Element>>& topLayerElements() const {
     return m_topLayerElements;
   }
   HTMLDialogElement* activeModalDialog() const;
 
-  // A non-null m_templateDocumentHost implies that |this| was created by ensureTemplateDocument().
+  // A non-null m_templateDocumentHost implies that |this| was created by
+  // ensureTemplateDocument().
   bool isTemplateDocument() const { return !!m_templateDocumentHost; }
   Document& ensureTemplateDocument();
   Document* templateDocumentHost() { return m_templateDocumentHost; }
 
   // TODO(thestig): Rename these and related functions, since we can call them
   // for controls outside of forms as well.
   void didAssociateFormControl(Element*);
 
   void addConsoleMessage(ConsoleMessage*) final;
 
@@ skipping 161 matching lines @@
   String nodeName() const final;
   NodeType getNodeType() const final;
   bool childTypeAllowed(NodeType) const final;
   Node* cloneNode(bool deep) final;
   void cloneDataFromDocument(const Document&);
   bool isSecureContextImpl(
       const SecureContextCheck priviligeContextCheck) const;
 
   ShadowCascadeOrder m_shadowCascadeOrder = ShadowCascadeNone;
 
-  const KURL& virtualURL() const
-      final;  // Same as url(), but needed for ExecutionContext to implement it without a performance loss for direct calls.
-  KURL virtualCompleteURL(const String&)
-      const final;  // Same as completeURL() for the same reason as above.
+  // Same as url(), but needed for ExecutionContext to implement it without a
+  // performance loss for direct calls.
+  const KURL& virtualURL() const final;
+  // Same as completeURL() for the same reason as above.
+  KURL virtualCompleteURL(const String&) const final;
 
   void updateTitle(const String&);
   void updateFocusAppearanceTimerFired(TimerBase*);
   void updateBaseURL();
 
   void executeScriptsWaitingForResources();
 
   void loadEventDelayTimerFired(TimerBase*);
   void pluginLoadingTimerFired(TimerBase*);
 
@@ skipping 22 matching lines @@
   }
 
   const OriginAccessEntry& accessEntryFromURL();
 
   DocumentLifecycle m_lifecycle;
 
   bool m_hasNodesWithPlaceholderStyle;
   bool m_evaluateMediaQueriesOnStyleRecalc;
 
   // If we do ignore the pending stylesheet count, then we need to add a boolean
-  // to track that this happened so that we can do a full repaint when the stylesheets
-  // do eventually load.
+  // to track that this happened so that we can do a full repaint when the
+  // stylesheets do eventually load.
   PendingSheetLayout m_pendingSheetLayout;
 
   Member<LocalFrame> m_frame;
   Member<LocalDOMWindow> m_domWindow;
   Member<HTMLImportsController> m_importsController;
 
   Member<ResourceFetcher> m_fetcher;
   Member<DocumentParser> m_parser;
   Member<ContextFeatures> m_contextFeatures;
 
   bool m_wellFormed;
 
   // Document URLs.
   KURL m_url;  // Document.URL: The URL from which this document was retrieved.
   KURL m_baseURL;  // Node.baseURI: The URL to use when resolving relative URLs.
-  KURL
-      m_baseURLOverride;  // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
-  KURL m_baseElementURL;  // The URL set by the <base> element.
-  KURL m_cookieURL;       // The URL to use for cookie access.
+  KURL m_baseURLOverride;  // An alternative base URL that takes precedence over
+                           // m_baseURL (but not m_baseElementURL).
+  KURL m_baseElementURL;   // The URL set by the <base> element.
+  KURL m_cookieURL;        // The URL to use for cookie access.
   std::unique_ptr<OriginAccessEntry> m_accessEntryFromURL;
 
   AtomicString m_baseTarget;
 
   // Mime-type of the document in case it was cloned or created by XHR.
   AtomicString m_mimeType;
 
   Member<DocumentType> m_docType;
   Member<DOMImplementation> m_implementation;
 
   Member<CSSStyleSheet> m_elemSheet;
 
   bool m_printing;
   bool m_wasPrinting;
   bool m_paginatedForScreen;
 
   CompatibilityMode m_compatibilityMode;
-  bool
-      m_compatibilityModeLocked;  // This is cheaper than making setCompatibilityMode virtual.
+  // This is cheaper than making setCompatibilityMode virtual.
+  bool m_compatibilityModeLocked;
 
   std::unique_ptr<CancellableTaskFactory>
       m_executeScriptsWaitingForResourcesTask;
 
   bool m_hasAutofocused;
   Timer<Document> m_clearFocusedElementTimer;
   Member<Element> m_autofocusElement;
   Member<Element> m_focusedElement;
   Member<Range> m_sequentialFocusNavigationStartingPoint;
   Member<Node> m_hoverNode;
@@ skipping 101 matching lines @@
 
   bool m_isViewSource;
   bool m_sawElementsInKnownNamespaces;
   bool m_isSrcdocDocument;
   bool m_isMobileDocument;
 
   LayoutView* m_layoutView;
 
   WeakMember<Document> m_contextDocument;
 
-  bool
-      m_hasFullscreenSupplement;  // For early return in Fullscreen::fromIfExists()
+  // For early return in Fullscreen::fromIfExists()
+  bool m_hasFullscreenSupplement;
 
   HeapVector<Member<Element>> m_topLayerElements;
 
   int m_loadEventDelayCount;
   Timer<Document> m_loadEventDelayTimer;
   Timer<Document> m_pluginLoadingTimer;
 
   ViewportDescription m_viewportDescription;
   ViewportDescription m_legacyViewportDescription;
   Length m_viewportDefaultMinWidth;
@@ skipping 57 matching lines @@
 
   bool m_visibilityWasLogged;
 
   Member<PropertyRegistry> m_propertyRegistry;
 };
 
 extern template class CORE_EXTERN_TEMPLATE_EXPORT Supplement<Document>;
 
 inline bool Document::shouldOverrideLegacyDescription(
     ViewportDescription::Type origin) const {
-  // The different (legacy) meta tags have different priorities based on the type
-  // regardless of which order they appear in the DOM. The priority is given by the
-  // ViewportDescription::Type enum.
+  // The different (legacy) meta tags have different priorities based on the
+  // type regardless of which order they appear in the DOM. The priority is
+  // given by the ViewportDescription::Type enum.
   return origin >= m_legacyViewportDescription.type;
 }
 
 inline void Document::scheduleLayoutTreeUpdateIfNeeded() {
   // Inline early out to avoid the function calls below.
   if (hasPendingVisualUpdate())
     return;
   if (shouldScheduleLayoutTreeUpdate() && needsLayoutTreeUpdate())
     scheduleLayoutTreeUpdate();
 }
 
 DEFINE_TYPE_CASTS(Document,
                   ExecutionContext,
                   context,
                   context->isDocument(),
                   context.isDocument());
 DEFINE_NODE_TYPE_CASTS(Document, isDocumentNode());
 
 #define DEFINE_DOCUMENT_TYPE_CASTS(thisType)                                \
   DEFINE_TYPE_CASTS(thisType, Document, document, document->is##thisType(), \
                     document.is##thisType())
 
-// This is needed to avoid ambiguous overloads with the Node and TreeScope versions.
+// This is needed to avoid ambiguous overloads with the Node and TreeScope
+// versions.
 DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(Document)
 
-// Put these methods here, because they require the Document definition, but we really want to inline them.
+// Put these methods here, because they require the Document definition, but we
+// really want to inline them.
 
 inline bool Node::isDocumentNode() const {
   return this == document();
 }
 
 Node* eventTargetNodeForDocument(Document*);
 
 DEFINE_TYPE_CASTS(TreeScope, Document, document, true, true);
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 CORE_EXPORT void showLiveDocumentInstances();
 #endif
 
 #endif  // Document_h