Merge ShadowRootRareData into ShadowRoot.

sky/engine/core/dom/shadow/ShadowRoot.cpp

 /*
  * Copyright (C) 2011 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 17 matching lines @@
 #include "sky/engine/core/dom/shadow/ShadowRoot.h"
 
 #include "sky/engine/bindings/core/v8/ExceptionState.h"
 #include "sky/engine/core/css/resolver/StyleResolver.h"
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/ElementTraversal.h"
 #include "sky/engine/core/dom/StyleEngine.h"
 #include "sky/engine/core/dom/Text.h"
 #include "sky/engine/core/dom/shadow/ElementShadow.h"
 #include "sky/engine/core/dom/shadow/InsertionPoint.h"
-#include "sky/engine/core/dom/shadow/ShadowRootRareData.h"
 #include "sky/engine/public/platform/Platform.h"
 
 namespace blink {
 
 struct SameSizeAsShadowRoot : public DocumentFragment, public TreeScope {
-    void* pointers[1];
-    unsigned countersAndFlags[1];
+    Vector<RefPtr<InsertionPoint>> vector;
+    unsigned countersAndFlags[3];
 };
 
 COMPILE_ASSERT(sizeof(ShadowRoot) == sizeof(SameSizeAsShadowRoot), shadowroot_should_stay_small);
 
 ShadowRoot::ShadowRoot(Document& document)
     : DocumentFragment(0, CreateShadowRoot)
     , TreeScope(*this, document)
+    , m_descendantContentElementCount(0)
+    , m_childShadowRootCount(0)
     , m_descendantInsertionPointsIsValid(false)
 {
 }
 
 ShadowRoot::~ShadowRoot()
 {
     // We cannot let ContainerNode destructor call willBeDeletedFromDocument()
     // for this ShadowRoot instance because TreeScope destructor
     // clears Node::m_treeScope thus ContainerNode is no longer able
     // to access it Document reference after that.
     willBeDeletedFromDocument();
 
     // We must remove all of our children first before the TreeScope destructor
     // runs so we don't go through TreeScopeAdopter for each child with a
     // destructed tree scope in each descendant.
     removeDetachedChildren();
 
     // We must call clearRareData() here since a ShadowRoot class inherits TreeScope
     // as well as Node. See a comment on TreeScope.h for the reason.
     if (hasRareData())
         clearRareData();
 }
 
 void ShadowRoot::dispose()
 {
+    invalidateDescendantInsertionPoints();
     removeDetachedChildren();
 }
 
 PassRefPtr<Node> ShadowRoot::cloneNode(bool, ExceptionState& exceptionState)
 {
     exceptionState.throwDOMException(DataCloneError, "ShadowRoot nodes are not clonable.");
     return nullptr;
 }
 
+PassRefPtr<Node> ShadowRoot::cloneNode(ExceptionState& exceptionState)
+{
+    return cloneNode(exceptionState);
+}
+
+PassRefPtr<Node> ShadowRoot::cloneNode(bool deep)
+{
+    return nullptr;
+}
+
 void ShadowRoot::recalcStyle(StyleRecalcChange change)
 {
     if (styleChangeType() >= SubtreeStyleChange)
         change = Force;
 
     // There's no style to update so just calling recalcStyle means we're updated.
     clearNeedsStyleRecalc();
 
     // FIXME: This doesn't handle :hover + div properly like Element::recalcStyle does.
     Text* lastTextNode = 0;
@@ skipping 30 matching lines @@
         root = insertionPoint->containingShadowRoot();
     if (root)
         root->removeChildShadowRoot();
 
     if (inActiveDocument())
         document().styleEngine()->removeTreeScope(*this);
 
     DocumentFragment::removedFrom(insertionPoint);
 }
 
-ShadowRootRareData* ShadowRoot::ensureShadowRootRareData()
+void ShadowRoot::didAddInsertionPoint()
 {
-    if (m_shadowRootRareData)
-        return m_shadowRootRareData.get();
-
-    m_shadowRootRareData = adoptPtr(new ShadowRootRareData);
-    return m_shadowRootRareData.get();
-}
-
-bool ShadowRoot::containsContentElements() const
-{
-    return m_shadowRootRareData ? m_shadowRootRareData->containsContentElements() : 0;
-}
-
-bool ShadowRoot::containsShadowRoots() const
-{
-    return m_shadowRootRareData ? m_shadowRootRareData->containsShadowRoots() : 0;
-}
-
-void ShadowRoot::didAddInsertionPoint(InsertionPoint* insertionPoint)
-{
-    ensureShadowRootRareData()->didAddInsertionPoint(insertionPoint);
+    ++m_descendantContentElementCount;
     invalidateDescendantInsertionPoints();
 }
 
-void ShadowRoot::didRemoveInsertionPoint(InsertionPoint* insertionPoint)
+void ShadowRoot::didRemoveInsertionPoint()
 {
-    m_shadowRootRareData->didRemoveInsertionPoint(insertionPoint);
+    ASSERT(m_descendantContentElementCount);
+    --m_descendantContentElementCount;
     invalidateDescendantInsertionPoints();
 }
 
 void ShadowRoot::addChildShadowRoot()
 {
-    ensureShadowRootRareData()->didAddChildShadowRoot();
+    ++m_childShadowRootCount;
 }
 
 void ShadowRoot::removeChildShadowRoot()
 {
-    // FIXME: Why isn't this an ASSERT?
-    if (!m_shadowRootRareData)
-        return;
-    m_shadowRootRareData->didRemoveChildShadowRoot();
-}
-
-unsigned ShadowRoot::childShadowRootCount() const
-{
-    return m_shadowRootRareData ? m_shadowRootRareData->childShadowRootCount() : 0;
+    ASSERT(m_childShadowRootCount);
+    --m_childShadowRootCount;
 }
 
 void ShadowRoot::invalidateDescendantInsertionPoints()
 {
     m_descendantInsertionPointsIsValid = false;
-    m_shadowRootRareData->clearDescendantInsertionPoints();
+    m_descendantInsertionPoints.clear();
+}
+
+bool ShadowRoot::containsContentElements() const
+{
+    return m_descendantContentElementCount;
+}
+
+bool ShadowRoot::containsShadowRoots() const
+{
+    return m_childShadowRootCount;
 }
 
 const Vector<RefPtr<InsertionPoint> >& ShadowRoot::descendantInsertionPoints()
 {
     DEFINE_STATIC_LOCAL(Vector<RefPtr<InsertionPoint> >, emptyList, ());
-    if (m_shadowRootRareData && m_descendantInsertionPointsIsValid)
-        return m_shadowRootRareData->descendantInsertionPoints();
+    if (m_descendantInsertionPointsIsValid)
+        return m_descendantInsertionPoints;
 
     m_descendantInsertionPointsIsValid = true;
 
-    if (!containsInsertionPoints())
+    if (!containsContentElements())
         return emptyList;
 
     Vector<RefPtr<InsertionPoint> > insertionPoints;
     for (InsertionPoint* insertionPoint = Traversal<InsertionPoint>::firstWithin(*this); insertionPoint; insertionPoint = Traversal<InsertionPoint>::next(*insertionPoint, this))
         insertionPoints.append(insertionPoint);
 
-    ensureShadowRootRareData()->setDescendantInsertionPoints(insertionPoints);
+    m_descendantInsertionPoints.swap(insertionPoints);
 
-    return m_shadowRootRareData->descendantInsertionPoints();
+    return m_descendantInsertionPoints;
 }
 
 }