Reflow comments in core/css

third_party/WebKit/Source/core/css/StyleSheetContents.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2012 Apple 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,
@@ skipping 22 matching lines @@
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/Histogram.h"
 #include "platform/tracing/TraceEvent.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
 // Rough size estimate for the memory cache.
 unsigned StyleSheetContents::estimatedSizeInBytes() const {
-  // Note that this does not take into account size of the strings hanging from various objects.
-  // The assumption is that nearly all of of them are atomic and would exist anyway.
+  // Note that this does not take into account size of the strings hanging from
+  // various objects. The assumption is that nearly all of of them are atomic
+  // and would exist anyway.
   unsigned size = sizeof(*this);
 
   // FIXME: This ignores the children of media rules.
   // Most rules are StyleRules.
   size += ruleCount() * StyleRule::averageSizeInBytes();
 
   for (unsigned i = 0; i < m_importRules.size(); ++i) {
     if (StyleSheetContents* sheet = m_importRules[i]->styleSheet())
       size += sheet->estimatedSizeInBytes();
   }
@@ skipping 59 matching lines @@
   if (!m_importRules.isEmpty())
     return false;
   // FIXME: Support cached stylesheets in import rules.
   if (m_ownerRule)
     return false;
   if (m_didLoadErrorOccur)
     return false;
   // It is not the original sheet anymore.
   if (m_isMutable)
     return false;
-  // If the header is valid we are not going to need to check the SecurityOrigin.
+  // If the header is valid we are not going to need to check the
+  // SecurityOrigin.
   // FIXME: Valid mime type avoids the check too.
   if (!m_hasSyntacticallyValidCSSHeader)
     return false;
   return true;
 }
 
 bool StyleSheetContents::isCacheableForStyleElement() const {
   // FIXME: Support copying import rules.
   if (!importRules().isEmpty())
     return false;
-  // Until import rules are supported in cached sheets it's not possible for loading to fail.
+  // Until import rules are supported in cached sheets it's not possible for
+  // loading to fail.
   DCHECK(!didLoadErrorOccur());
   // It is not the original sheet anymore.
   if (isMutable())
     return false;
   if (!hasSyntacticallyValidCSSHeader())
     return false;
   return true;
 }
 
 void StyleSheetContents::parserAppendRule(StyleRuleBase* rule) {
@@ skipping 69 matching lines @@
     if (!rule->isImportRule())
       return false;
 
     StyleRuleImport* importRule = toStyleRuleImport(rule);
     if (importRule->mediaQueries())
       setHasMediaQueries();
 
     m_importRules.insert(index, importRule);
     m_importRules[index]->setParentStyleSheet(this);
     m_importRules[index]->requestStyleSheet();
-    // FIXME: Stylesheet doesn't actually change meaningfully before the imported sheets are loaded.
+    // FIXME: Stylesheet doesn't actually change meaningfully before the
+    // imported sheets are loaded.
     return true;
   }
   // Inserting @import rule after a non-import rule is not allowed.
   if (rule->isImportRule())
     return false;
 
   index -= m_importRules.size();
 
   if (index < m_namespaceRules.size() ||
       (index == m_namespaceRules.size() && rule->isNamespaceRule())) {
-    // Inserting non-namespace rules other than import rule before @namespace is not allowed.
+    // Inserting non-namespace rules other than import rule before @namespace is
+    // not allowed.
     if (!rule->isNamespaceRule())
       return false;
-    // Inserting @namespace rule when rules other than import/namespace/charset are present is not allowed.
+    // Inserting @namespace rule when rules other than import/namespace/charset
+    // are present is not allowed.
     if (!m_childRules.isEmpty())
       return false;
 
     StyleRuleNamespace* namespaceRule = toStyleRuleNamespace(rule);
     m_namespaceRules.insert(index, namespaceRule);
-    // For now to be compatible with IE and Firefox if namespace rule with same prefix is added
-    // irrespective of adding the rule at any index, last added rule's value is considered.
-    // TODO (ramya.v@samsung.com): As per spec last valid rule should be considered,
-    // which means if namespace rule is added in the middle of existing namespace rules,
-    // rule which comes later in rule list with same prefix needs to be considered.
+    // For now to be compatible with IE and Firefox if namespace rule with same
+    // prefix is added irrespective of adding the rule at any index, last added
+    // rule's value is considered.
+    // TODO (ramya.v@samsung.com): As per spec last valid rule should be
+    // considered, which means if namespace rule is added in the middle of
+    // existing namespace rules, rule which comes later in rule list with same
+    // prefix needs to be considered.
     parserAddNamespace(namespaceRule->prefix(), namespaceRule->uri());
     return true;
   }
 
   if (rule->isNamespaceRule())
     return false;
 
   index -= m_namespaceRules.size();
 
   m_childRules.insert(index, rule);
@@ skipping 48 matching lines @@
 void StyleSheetContents::parseAuthorStyleSheet(
     const CSSStyleSheetResource* cachedStyleSheet,
     const SecurityOrigin* securityOrigin) {
   TRACE_EVENT1("blink,devtools.timeline", "ParseAuthorStyleSheet", "data",
                InspectorParseAuthorStyleSheetEvent::data(cachedStyleSheet));
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Style.AuthorStyleSheet.ParseTime");
 
   bool isSameOriginRequest =
       securityOrigin && securityOrigin->canRequest(baseURL());
 
-  // When the response was fetched via the Service Worker, the original URL may not be same as the base URL.
-  // TODO(horo): When we will use the original URL as the base URL, we can remove this check. crbug.com/553535
+  // When the response was fetched via the Service Worker, the original URL may
+  // not be same as the base URL.
+  // TODO(horo): When we will use the original URL as the base URL, we can
+  // remove this check. crbug.com/553535
   if (cachedStyleSheet->response().wasFetchedViaServiceWorker()) {
     const KURL originalURL(
         cachedStyleSheet->response().originalURLViaServiceWorker());
     // |originalURL| is empty when the response is created in the SW.
     if (!originalURL.isEmpty() && !securityOrigin->canRequest(originalURL))
       isSameOriginRequest = false;
   }
 
   CSSStyleSheetResource::MIMETypeCheck mimeTypeCheck =
       isQuirksModeBehavior(m_parserContext.mode()) && isSameOriginRequest
@@ skipping 47 matching lines @@
   StyleSheetContents* parentSheet = parentStyleSheet();
   if (parentSheet) {
     parentSheet->checkLoaded();
     return;
   }
 
   ASSERT(this == rootStyleSheet());
   if (m_loadingClients.isEmpty())
     return;
 
-  // Avoid |CSSSStyleSheet| and |ownerNode| being deleted by scripts that run via
-  // ScriptableDocumentParser::executeScriptsWaitingForResources(). Also protect
-  // the |CSSStyleSheet| from being deleted during iteration via the |sheetLoaded|
-  // method.
+  // Avoid |CSSSStyleSheet| and |ownerNode| being deleted by scripts that run
+  // via ScriptableDocumentParser::executeScriptsWaitingForResources(). Also
+  // protect the |CSSStyleSheet| from being deleted during iteration via the
+  // |sheetLoaded| method.
   //
   // When a sheet is loaded it is moved from the set of loading clients
   // to the set of completed clients. We therefore need the copy in order to
   // not modify the set while iterating it.
   HeapVector<Member<CSSStyleSheet>> loadingClients;
   copyToVector(m_loadingClients, loadingClients);
 
   for (unsigned i = 0; i < loadingClients.size(); ++i) {
     if (loadingClients[i]->loadCompleted())
       continue;
 
-    // sheetLoaded might be invoked after its owner node is removed from document.
+    // sheetLoaded might be invoked after its owner node is removed from
+    // document.
     if (Node* ownerNode = loadingClients[i]->ownerNode()) {
       if (loadingClients[i]->sheetLoaded())
         ownerNode->notifyLoadedSheetAndAllCriticalSubresources(
             m_didLoadErrorOccur ? Node::ErrorOccurredLoadingSubresource
                                 : Node::NoErrorLoadingSubresource);
     }
   }
 }
 
 void StyleSheetContents::notifyLoadedSheet(const CSSStyleSheetResource* sheet) {
   ASSERT(sheet);
   m_didLoadErrorOccur |= sheet->errorOccurred();
-  // updateLayoutIgnorePendingStyleSheets can cause us to create the RuleSet on this
-  // sheet before its imports have loaded. So clear the RuleSet when the imports
-  // load since the import's subrules are flattened into its parent sheet's RuleSet.
+  // updateLayoutIgnorePendingStyleSheets can cause us to create the RuleSet on
+  // this sheet before its imports have loaded. So clear the RuleSet when the
+  // imports load since the import's subrules are flattened into its parent
+  // sheet's RuleSet.
   clearRuleSet();
 }
 
 void StyleSheetContents::startLoadingDynamicSheet() {
   StyleSheetContents* root = rootStyleSheet();
   for (const auto& client : root->m_loadingClients)
     client->startLoadingDynamicSheet();
   // Copy the completed clients to a vector for iteration.
-  // startLoadingDynamicSheet will move the style sheet from the
-  // completed state to the loading state which modifies the set of
-  // completed clients. We therefore need the copy in order to not
-  // modify the set of completed clients while iterating it.
+  // startLoadingDynamicSheet will move the style sheet from the completed state
+  // to the loading state which modifies the set of completed clients. We
+  // therefore need the copy in order to not modify the set of completed clients
+  // while iterating it.
   HeapVector<Member<CSSStyleSheet>> completedClients;
   copyToVector(root->m_completedClients, completedClients);
   for (unsigned i = 0; i < completedClients.size(); ++i)
     completedClients[i]->startLoadingDynamicSheet();
 }
 
 StyleSheetContents* StyleSheetContents::rootStyleSheet() const {
   const StyleSheetContents* root = this;
   while (root->parentStyleSheet())
     root = root->parentStyleSheet();
@@ skipping 68 matching lines @@
 }
 
 StyleSheetContents* StyleSheetContents::parentStyleSheet() const {
   return m_ownerRule ? m_ownerRule->parentStyleSheet() : nullptr;
 }
 
 void StyleSheetContents::registerClient(CSSStyleSheet* sheet) {
   ASSERT(!m_loadingClients.contains(sheet) &&
          !m_completedClients.contains(sheet));
 
-  // InspectorCSSAgent::buildObjectForRule creates CSSStyleSheet without any owner node.
+  // InspectorCSSAgent::buildObjectForRule creates CSSStyleSheet without any
+  // owner node.
   if (!sheet->ownerDocument())
     return;
 
   if (Document* document = clientSingleOwnerDocument()) {
     if (sheet->ownerDocument() != document)
       m_hasSingleOwnerDocument = false;
   }
   m_loadingClients.add(sheet);
 }
 
@@ skipping 58 matching lines @@
 void StyleSheetContents::clearRuleSet() {
   if (StyleSheetContents* parentSheet = parentStyleSheet())
     parentSheet->clearRuleSet();
 
   // Don't want to clear the StyleResolver if the RuleSet hasn't been created
   // since we only clear the StyleResolver so that it's members are properly
   // updated in ScopedStyleResolver::addRulesFromSheet.
   if (!m_ruleSet)
     return;
 
-  // Clearing the ruleSet means we need to recreate the styleResolver data structures.
-  // See the StyleResolver calls in ScopedStyleResolver::addRulesFromSheet.
+  // Clearing the ruleSet means we need to recreate the styleResolver data
+  // structures. See the StyleResolver calls in
+  // ScopedStyleResolver::addRulesFromSheet.
   clearResolvers(m_loadingClients);
   clearResolvers(m_completedClients);
   m_ruleSet.clear();
 }
 
 static void removeFontFaceRules(HeapHashSet<WeakMember<CSSStyleSheet>>& clients,
                                 const StyleRuleFontFace* fontFaceRule) {
   for (const auto& sheet : clients) {
     if (Node* ownerNode = sheet->ownerNode())
       ownerNode->document().styleEngine().removeFontFaceRules(
@@ skipping 41 matching lines @@
   visitor->trace(m_importRules);
   visitor->trace(m_namespaceRules);
   visitor->trace(m_childRules);
   visitor->trace(m_loadingClients);
   visitor->trace(m_completedClients);
   visitor->trace(m_ruleSet);
   visitor->trace(m_referencedFromResource);
 }
 
 }  // namespace blink