[LazyParseCSS] Ensure UseCounting has parity with strict parsing

third_party/WebKit/Source/core/css/parser/CSSLazyParsingState.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSLazyParsingState.h"
 #include "core/css/parser/CSSParserTokenRange.h"
+#include "core/dom/Document.h"
 #include "core/frame/UseCounter.h"
 
 namespace blink {
 
 CSSLazyParsingState::CSSLazyParsingState(const CSSParserContext& context,
                                          Vector<String> escapedStrings,
                                          const String& sheetText,
                                          StyleSheetContents* contents)
     : m_context(context),
       m_escapedStrings(std::move(escapedStrings)),
       m_sheetText(sheetText),
       m_owningContents(contents) {}
 
 const CSSParserContext& CSSLazyParsingState::context() {
   DCHECK(m_owningContents);
-  UseCounter* sheetCounter = UseCounter::getFrom(m_owningContents);
-  if (sheetCounter != m_context.useCounter())
-    m_context = CSSParserContext(m_context, sheetCounter);
+  Document* document = m_owningContents->anyOwnerDocument();
+  if (document != m_document) {

[rune, 2016/12/02 22:18:09]

Couldn't you check if m_document is nullptr before calling anyOwnerDocument()?

Like:

if (!m_document) {
  m_document = m_owningContents->anyOwnerDocument();
  m_context = ...;
}

Or is it a problem if you use the use-counter from a document which is no longer
a client, but before it is garbage collected and the weak reference is not
cleared?

If it's theoretically possible that you enter lazy parsing after all clients
have been cleared, but documents are not garbage collected, the if (document !=
m_document) variant could set m_document from a non-null to a nullptr.

[Charlie Harrison, 2016/12/02 22:38:46]

Yes I think we can do this. My reason for doing it like this is that it is much
easier to unit test this code. In addition, using a if (!m_document) check is
much faster than pulling the owning document.

+    // Since all StyleSheetContents are parsed with a single owner document, try
+    // as best as possible to grab a valid UseCounter if the underlying document
+    // has gone away.
+    m_document = document;
+    m_context = CSSParserContext(m_context, UseCounter::getFrom(m_document));
+  }
   return m_context;
 }
 
 bool CSSLazyParsingState::shouldLazilyParseProperties(
     const CSSSelectorList& selectors,
     const CSSParserTokenRange& block) {
   // Simple heuristic for an empty block. Note that |block| here does not
   // include {} brackets. We avoid lazy parsing empty blocks so we can avoid
   // considering them when possible for matching. Lazy blocks must always be
   // considered. Three tokens is a reasonable minimum for a block:
@@ skipping 11 matching lines @@
       const CSSSelector::PseudoType type(current->getPseudoType());
       if (type == CSSSelector::PseudoBefore || type == CSSSelector::PseudoAfter)
         return false;
       if (current->relation() != CSSSelector::SubSelector)
         break;
     }
   }
   return true;
 }
 
+DEFINE_TRACE(CSSLazyParsingState) {
+  visitor->trace(m_owningContents);
+  visitor->trace(m_document);
+}
+
 }  // namespace blink