Use new is*Element() helper functions in DOM code

Source/core/dom/shadow/ElementShadow.cpp

 /*
  * Copyright (C) 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 70 matching lines @@
 }
 
 void DistributionPool::distributeTo(InsertionPoint* insertionPoint, ElementShadow* elementShadow)
 {
     ContentDistribution distribution;
 
     for (size_t i = 0; i < m_nodes.size(); ++i) {
         if (m_distributed[i])
             continue;
 
-        if (insertionPoint->hasTagName(HTMLNames::contentTag) && !toHTMLContentElement(insertionPoint)->canSelectNode(m_nodes, i))
+        if (isHTMLContentElement(*insertionPoint) && !toHTMLContentElement(insertionPoint)->canSelectNode(m_nodes, i))
             continue;
 
         Node* node = m_nodes[i];
         distribution.append(node);
         elementShadow->didDistributeNode(node, insertionPoint);
         m_distributed[i] = true;
     }
 
     // Distributes fallback elements
     if (insertionPoint->isContentInsertionPoint() && distribution.isEmpty()) {
@@ skipping 193 matching lines @@
     Vector<HTMLShadowElement*, 32> shadowInsertionPoints;
     DistributionPool pool(*host());
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         HTMLShadowElement* shadowInsertionPoint = 0;
         const Vector<RefPtr<InsertionPoint> >& insertionPoints = root->descendantInsertionPoints();
         for (size_t i = 0; i < insertionPoints.size(); ++i) {
             InsertionPoint* point = insertionPoints[i].get();
             if (!point->isActive())
                 continue;
-            if (point->hasTagName(HTMLNames::shadowTag)) {
+            if (isHTMLShadowElement(*point)) {
                 ASSERT(!shadowInsertionPoint);
                 shadowInsertionPoint = toHTMLShadowElement(point);
                 shadowInsertionPoints.append(shadowInsertionPoint);
             } else {
                 pool.distributeTo(point, this);
                 if (ElementShadow* shadow = shadowWhereNodeCanBeDistributed(*point))
                     shadow->setNeedsDistributionRecalc();
             }
         }
     }
@@ skipping 35 matching lines @@
 }
 
 void ElementShadow::collectSelectFeatureSetFrom(ShadowRoot& root)
 {
     if (!root.containsShadowRoots() && !root.containsContentElements())
         return;
 
     for (Element* element = ElementTraversal::firstWithin(root); element; element = ElementTraversal::next(*element, &root)) {
         if (ElementShadow* shadow = element->shadow())
             m_selectFeatures.add(shadow->ensureSelectFeatureSet());
-        if (!element->hasTagName(HTMLNames::contentTag))
+        if (!isHTMLContentElement(*element))
             continue;
-        const CSSSelectorList& list = toHTMLContentElement(element)->selectorList();
+        const CSSSelectorList& list = toHTMLContentElement(*element).selectorList();
         for (const CSSSelector* selector = list.first(); selector; selector = CSSSelectorList::next(*selector)) {
             for (const CSSSelector* component = selector; component; component = component->tagHistory())
                 m_selectFeatures.collectFeaturesFromSelector(*component);
         }
     }
 }
 
 void ElementShadow::didAffectSelector(AffectedSelectorMask mask)
 {
     if (ensureSelectFeatureSet().hasSelectorFor(mask))
@@ skipping 12 matching lines @@
 
 void ElementShadow::clearDistribution()
 {
     m_nodeToInsertionPoints.clear();
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot())
         root->setShadowInsertionPointOfYoungerShadowRoot(nullptr);
 }
 
 } // namespace