style: Rename the PseudoId enum values to CamelCase and prefix them.

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)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1521 matching lines @@
     if (hasRareData() && !layoutObject()) {
         if (ElementAnimations* elementAnimations = elementRareData()->elementAnimations()) {
             elementAnimations->cssAnimations().cancel();
             elementAnimations->setAnimationStyleChange(false);
         }
     }
 
     SelectorFilterParentScope filterScope(*this);
     StyleSharingDepthScope sharingScope(*this);
 
-    createPseudoElementIfNeeded(BEFORE);
+    createPseudoElementIfNeeded(PseudoIdBefore);
 
     // When a shadow root exists, it does the work of attaching the children.
     if (ElementShadow* shadow = this->shadow())
         shadow->attach(context);
 
     ContainerNode::attach(context);
 
-    createPseudoElementIfNeeded(AFTER);
-    createPseudoElementIfNeeded(BACKDROP);
+    createPseudoElementIfNeeded(PseudoIdAfter);
+    createPseudoElementIfNeeded(PseudoIdBackdrop);
 
     // We create the first-letter element after the :before, :after and
     // children are attached because the first letter text could come
     // from any of them.
-    createPseudoElementIfNeeded(FIRST_LETTER);
+    createPseudoElementIfNeeded(PseudoIdFirstLetter);
 }
 
 void Element::detach(const AttachContext& context)
 {
     HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
     cancelFocusAppearanceUpdate();
     removeCallbackSelectors();
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
         data->clearPseudoElements();
@@ skipping 50 matching lines @@
 
     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
     if (!pseudoStyleCache)
         return false;
 
     size_t cacheSize = pseudoStyleCache->size();
     for (size_t i = 0; i < cacheSize; ++i) {
         RefPtr<ComputedStyle> newPseudoStyle;
         RefPtr<ComputedStyle> oldPseudoStyle = pseudoStyleCache->at(i);
         PseudoId pseudoId = oldPseudoStyle->styleType();
-        if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
+        if (pseudoId == PseudoIdFirstLine || pseudoId == PseudoIdFirstLineInherited)
             newPseudoStyle = layoutObject()->uncachedFirstLineStyle(newStyle);
         else
             newPseudoStyle = layoutObject()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
         if (!newPseudoStyle)
             return true;
         if (*oldPseudoStyle != *newPseudoStyle || oldPseudoStyle->font().loadingCustomFonts() != newPseudoStyle->font().loadingCustomFonts()) {
-            if (pseudoId < FIRST_INTERNAL_PSEUDOID)
+            if (pseudoId < FirstInternalPseudoId)
                 newStyle->setHasPseudoStyle(pseudoId);
             newStyle->addCachedPseudoStyle(newPseudoStyle);
-            if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
+            if (pseudoId == PseudoIdFirstLine || pseudoId == PseudoIdFirstLineInherited)
                 layoutObject()->firstLineStyleDidChange(*oldPseudoStyle, *newPseudoStyle);
             return true;
         }
     }
     return false;
 }
 
 PassRefPtr<ComputedStyle> Element::styleForLayoutObject()
 {
     ASSERT(document().inStyleRecalc());
@@ skipping 54 matching lines @@
         if (parentComputedStyle())
             change = recalcOwnStyle(change);
         clearNeedsStyleRecalc();
     }
 
     // If we reattached we don't need to recalc the style of our descendants anymore.
     if ((change >= UpdatePseudoElements && change < Reattach) || childNeedsStyleRecalc()) {
         SelectorFilterParentScope filterScope(*this);
         StyleSharingDepthScope sharingScope(*this);
 
-        updatePseudoElement(BEFORE, change);
+        updatePseudoElement(PseudoIdBefore, change);
 
         if (change > UpdatePseudoElements || childNeedsStyleRecalc()) {
             for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
                 if (root->shouldCallRecalcStyle(change))
                     root->recalcStyle(change);
             }
             recalcChildStyle(change);
         }
 
-        updatePseudoElement(AFTER, change);
-        updatePseudoElement(BACKDROP, change);
+        updatePseudoElement(PseudoIdAfter, change);
+        updatePseudoElement(PseudoIdBackdrop, change);
 
         // If our children have changed then we need to force the first-letter
         // checks as we don't know if they effected the first letter or not.
         // This can be seen when a child transitions from floating to
         // non-floating we have to take it into account for the first letter.
-        updatePseudoElement(FIRST_LETTER, childNeedsStyleRecalc() ? Force : change);
+        updatePseudoElement(PseudoIdFirstLetter, childNeedsStyleRecalc() ? Force : change);
 
         clearChildNeedsStyleRecalc();
     }
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
@@ skipping 1100 matching lines @@
     if (document().focusedElement() == this)
         document().cancelFocusAppearanceUpdate();
 }
 
 void Element::updatePseudoElement(PseudoId pseudoId, StyleRecalcChange change)
 {
     ASSERT(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
 
     if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change))) {
-        if (pseudoId == FIRST_LETTER && updateFirstLetter(element))
+        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);
 
         // 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)))
             elementRareData()->setPseudoElement(pseudoId, nullptr);
-    } else if (pseudoId == FIRST_LETTER && element && change >= UpdatePseudoElements && !FirstLetterPseudoElement::firstLetterTextLayoutObject(*element)) {
+    } 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) {
         createPseudoElementIfNeeded(pseudoId);
     }
 }
 
 // If we're updating first letter, and the current first letter layoutObject
 // is not the same as the one we're currently using we need to re-create
 // the first letter layoutObject.
 bool Element::updateFirstLetter(Element* element)
 {
     LayoutObject* remainingTextLayoutObject = FirstLetterPseudoElement::firstLetterTextLayoutObject(*element);
     if (!remainingTextLayoutObject || remainingTextLayoutObject != toFirstLetterPseudoElement(element)->remainingTextLayoutObject()) {
         // We have to clear out the old first letter here because when it is
         // disposed it will set the original text back on the remaining text
         // layoutObject. If we dispose after creating the new one we will get
         // incorrect results due to setting the first letter back.
         if (remainingTextLayoutObject)
             element->reattach();
         else
-            elementRareData()->setPseudoElement(FIRST_LETTER, nullptr);
+            elementRareData()->setPseudoElement(PseudoIdFirstLetter, nullptr);
         return true;
     }
     return false;
 }
 
 void Element::createPseudoElementIfNeeded(PseudoId pseudoId)
 {
     if (isPseudoElement())
         return;
 
     // Document::ensureStyleResolver is not inlined and shows up on profiles, avoid it here.
     RefPtrWillBeRawPtr<PseudoElement> element = document().styleEngine().ensureResolver().createPseudoElementIfNeeded(*this, pseudoId);
     if (!element)
         return;
 
-    if (pseudoId == BACKDROP)
+    if (pseudoId == PseudoIdBackdrop)
         document().addToTopLayer(element.get(), this);
     element->insertedInto(this);
     element->attach();
 
     InspectorInstrumentation::pseudoElementCreated(element.get());
 
     ensureElementRareData().setPseudoElement(pseudoId, element.release());
 }
 
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
@@ skipping 749 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink