Move getCached/getUncachedPseudoStyle to Element.

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 3243 matching lines @@
   PseudoElement* element = pseudoElement(pseudoId);
 
   if (element && (change == UpdatePseudoElements ||
                   element->shouldCallRecalcStyle(change))) {
     if (pseudoId == PseudoIdFirstLetter && updateFirstLetter(element))
       return;
 
     // Need to clear the cached style if the PseudoElement wants a recalc so it
     // computes a new style.
     if (element->needsStyleRecalc())
-      layoutObject()->mutableStyle()->removeCachedPseudoStyle(pseudoId);
+      mutableComputedStyle()->removeCachedPseudoStyle(pseudoId);
 
     // PseudoElement styles hang off their parent element's style so if we
     // needed a style recalc we should Force one on the pseudo.  FIXME: We
     // should figure out the right text sibling to pass.
     element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
     // Wait until our parent is not displayed or
     // pseudoElementLayoutObjectIsNeeded is false, otherwise we could
     // continuously create and destroy PseudoElements when
     // LayoutObject::isChildAllowed on our parent returns false for the
     // PseudoElement's layoutObject for each style recalc.
-    if (!layoutObject() ||
-        !pseudoElementLayoutObjectIsNeeded(
-            layoutObject()->getCachedPseudoStyle(pseudoId)))
+    if (!layoutObject() || !pseudoElementLayoutObjectIsNeeded(
+                               pseudoStyle(PseudoStyleRequest(pseudoId))))
       elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (pseudoId == PseudoIdFirstLetter && element &&
              change >= UpdatePseudoElements &&
              !FirstLetterPseudoElement::firstLetterTextLayoutObject(*element)) {
     // This can happen if we change to a float, for example. We need to cleanup
     // the first-letter pseudoElement and then fix the text of the original
     // remaining text layoutObject.  This can be seen in Test 7 of
     // fast/css/first-letter-removed-added.html
     elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (change >= UpdatePseudoElements) {
@@ skipping 48 matching lines @@
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const {
   return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : nullptr;
 }
 
 LayoutObject* Element::pseudoElementLayoutObject(PseudoId pseudoId) const {
   if (PseudoElement* element = pseudoElement(pseudoId))
     return element->layoutObject();
   return nullptr;
 }
 
+ComputedStyle* Element::pseudoStyle(const PseudoStyleRequest& request,
+                                    const ComputedStyle* parentStyle) {
+  ComputedStyle* style = mutableComputedStyle();
+
+  if (!style || (request.pseudoId < FirstInternalPseudoId &&
+                 !style->hasPseudoStyle(request.pseudoId))) {
+    return nullptr;
+  }
+
+  if (ComputedStyle* cached = style->getCachedPseudoStyle(request.pseudoId))
+    return cached;
+
+  RefPtr<ComputedStyle> result = getUncachedPseudoStyle(request, parentStyle);
+  if (result)
+    return style->addCachedPseudoStyle(result.release());
+  return nullptr;
+}
+
+PassRefPtr<ComputedStyle> Element::getUncachedPseudoStyle(
+    const PseudoStyleRequest& request,
+    const ComputedStyle* parentStyle) {
+  const ComputedStyle* style = computedStyle();
+  const bool isBeforeOrAfter =
+      request.pseudoId == PseudoIdBefore || request.pseudoId == PseudoIdAfter;
+
+  DCHECK(style);
+  DCHECK(!parentStyle || !isBeforeOrAfter);
+
+  if (isBeforeOrAfter) {
+    LayoutObject* parentLayoutObject = layoutObject();
+    if (!parentLayoutObject && hasDisplayContentsStyle()) {
+      parentLayoutObject =
+          LayoutTreeBuilderTraversal::parentLayoutObject(*this);
+    }
+    if (!parentLayoutObject)
+      return nullptr;
+    return document().ensureStyleResolver().pseudoStyleForElement(
+        this, request, style, parentLayoutObject->style());
+  }
+
+  if (!layoutObject())
+    return nullptr;
+
+  if (!parentStyle)
+    parentStyle = style;
+
+  if (request.pseudoId == PseudoIdFirstLineInherited) {
+    RefPtr<ComputedStyle> result =
+        document().ensureStyleResolver().styleForElement(
+            this, parentStyle, parentStyle, DisallowStyleSharing);
+    result->setStyleType(PseudoIdFirstLineInherited);
+    return result.release();
+  }
+
+  return document().ensureStyleResolver().pseudoStyleForElement(
+      this, request, parentStyle, parentStyle);
+}
+
 bool Element::matches(const AtomicString& selectors,
                       ExceptionState& exceptionState) {
   SelectorQuery* selectorQuery = document().selectorQueryCache().add(
       selectors, document(), exceptionState);
   if (!selectorQuery)
     return false;
   return selectorQuery->matches(*this);
 }
 
 Element* Element::closest(const AtomicString& selectors,
@@ skipping 814 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink