Reflow comments in core/css/invalidation.

third_party/WebKit/Source/core/css/invalidation/StyleSheetInvalidationAnalysis.cpp

 /*
  * Copyright (C) 2012 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 36 matching lines @@
   for (unsigned i = 0; i < sheets.size() && !m_dirtiesAllStyle; ++i)
     analyzeStyleSheet(sheets[i]);
 }
 
 static bool determineSelectorScopes(const CSSSelectorList& selectorList,
                                     HashSet<StringImpl*>& idScopes,
                                     HashSet<StringImpl*>& classScopes) {
   for (const CSSSelector* selector = selectorList.first(); selector;
        selector = CSSSelectorList::next(*selector)) {
     const CSSSelector* scopeSelector = 0;
-    // This picks the widest scope, not the narrowest, to minimize the number of found scopes.
+    // This picks the widest scope, not the narrowest, to minimize the number of
+    // found scopes.
     for (const CSSSelector* current = selector; current;
          current = current->tagHistory()) {
       // Prefer ids over classes.
       if (current->match() == CSSSelector::Id)
         scopeSelector = current;
       else if (current->match() == CSSSelector::Class &&
                (!scopeSelector || scopeSelector->match() != CSSSelector::Id))
         scopeSelector = current;
       CSSSelector::RelationType relation = current->relation();
-      // FIXME: it would be better to use setNeedsStyleRecalc for all shadow hosts matching
+      // FIXME: it would be better to use setNeedsStyleRecalc for all shadow
+      // hosts matching
       // scopeSelector. Currently requests full style recalc.
       if (relation == CSSSelector::ShadowDeep ||
           relation == CSSSelector::ShadowPseudo)
         return false;
       if (relation != CSSSelector::Descendant &&
           relation != CSSSelector::Child &&
           relation != CSSSelector::SubSelector)
         break;
     }
     if (!scopeSelector)
       return false;
     ASSERT(scopeSelector->match() == CSSSelector::Class ||
            scopeSelector->match() == CSSSelector::Id);
     if (scopeSelector->match() == CSSSelector::Id)
       idScopes.add(scopeSelector->value().impl());
     else
       classScopes.add(scopeSelector->value().impl());
   }
   return true;
 }
 
 static bool ruleAdditionMightRequireDocumentStyleRecalc(StyleRuleBase* rule) {
   // This function is conservative. We only return false when we know that
   // the added @rule can't require style recalcs.
   switch (rule->type()) {
-    case StyleRule::
-        Import:  // Whatever we import should do its own analysis, we don't need to invalidate the document here!
-    case StyleRule::
-        Page:  // Page rules apply only during printing, we force a full-recalc before printing.
+    case StyleRule::Import:  // Whatever we import should do its own analysis,
+                             // we don't need to invalidate the document here!
+    case StyleRule::Page:  // Page rules apply only during printing, we force a
+                           // full-recalc before printing.
       return false;
 
-    case StyleRule::
-        Media:  // If the media rule doesn't apply, we could avoid recalc.
-    case StyleRule::
-        FontFace:  // If the fonts aren't in use, we could avoid recalc.
-    case StyleRule::
-        Supports:  // If we evaluated the supports-clause we could avoid recalc.
-    case StyleRule::
-        Viewport:  // If the viewport doesn't match, we could avoid recalcing.
+    case StyleRule::Media:  // If the media rule doesn't apply, we could avoid
+                            // recalc.
+    case StyleRule::FontFace:  // If the fonts aren't in use, we could avoid
+                               // recalc.
+    case StyleRule::Supports:  // If we evaluated the supports-clause we could
+                               // avoid recalc.
+    case StyleRule::Viewport:  // If the viewport doesn't match, we could avoid
+                               // recalcing.
       return true;
 
     // These should all be impossible to reach:
     case StyleRule::Charset:
     case StyleRule::Keyframe:
     case StyleRule::Namespace:
     case StyleRule::Style:
     case StyleRule::Keyframes:
       break;
   }
   ASSERT_NOT_REACHED();
   return true;
 }
 
 void StyleSheetInvalidationAnalysis::analyzeStyleSheet(
     StyleSheetContents* styleSheetContents) {
-  // Updating the style on the shadow DOM for image fallback content can bring us here when imports
-  // are still getting loaded in the main document. Just need to exit early as we will return here
-  // when the imports finish loading.
+  // Updating the style on the shadow DOM for image fallback content can bring
+  // us here when imports are still getting loaded in the main document. Just
+  // need to exit early as we will return here when the imports finish loading.
   if (styleSheetContents->isLoading())
     return;
 
   // See if all rules on the sheet are scoped to some specific ids or classes.
   // Then test if we actually have any of those in the tree at the moment.
   const HeapVector<Member<StyleRuleImport>>& importRules =
       styleSheetContents->importRules();
   for (unsigned i = 0; i < importRules.size(); ++i) {
     if (!importRules[i]->styleSheet())
       continue;
@@ skipping 70 matching lines @@
                                        StyleChangeReason::StyleSheetChange));
       // The whole subtree is now invalidated, we can skip to the next sibling.
       element = ElementTraversal::nextSkippingChildren(*element);
       continue;
     }
     element = ElementTraversal::next(*element);
   }
 }
 
 }  // namespace blink