ChangeLog

2012-07-12  Ryosuke Niwa  <rniwa@webkit.org>

        Move m_type and m_hasNameCache from HTMLCollectionCacheBase to DynamicNodeListCacheBase for better bit packing

        https://bugs.webkit.org/show_bug.cgi?id=91164

        Reviewed by NOBODY (OOPS!).

        Moved m_type and m_hasNameCache from HTMLCollection and renamed them to m_collectionType and m_isNameCacheValid.

        Also renamed shouldIncludeChildren to shouldOnlyIncludeDirectChildren and negated the return value since

        all HTMLCollection include children in the collection and the function was meant to tell us whether the collection

        should include descendents that are not direct children of base().

        In addition, renamed nextNodeOrSibling to nextNode since "or sibling" doesn't seem to add any semantic clarity.

        * dom/DynamicNodeList.h:

        (WebCore::DynamicNodeListCacheBase::DynamicNodeListCacheBase):

        (DynamicNodeListCacheBase):

        (WebCore::DynamicNodeListCacheBase::type):

        (WebCore::DynamicNodeListCacheBase::hasNameCache):

        (WebCore::DynamicNodeListCacheBase::setHasNameCache):

        (WebCore::DynamicNodeListCacheBase::clearCache):

        * html/HTMLCollection.cpp:

        (WebCore::shouldOnlyIncludeDirectChildren):

        (WebCore::HTMLCollection::HTMLCollection):

        (WebCore::HTMLCollection::isAcceptableElement):

        (WebCore::nextNode):

        (WebCore::HTMLCollection::itemAfter):

        * html/HTMLCollection.h:

        (WebCore::HTMLCollectionCacheBase::HTMLCollectionCacheBase):

        (HTMLCollectionCacheBase):

        (WebCore::HTMLCollectionCacheBase::clearCache):

2012-07-12  Dana Jansens  <danakj@chromium.org>

        [chromium] Remove the RenderPass pointer from RenderPassDrawQuad

122529

Source/WebCore/dom/DynamicNodeList.h

#ifndef DynamicNodeList_h

#define DynamicNodeList_h

27#include "CollectionType.h"

#include "Document.h"

#include "NodeList.h"

#include <wtf/Forward.h>

@@public:

    DynamicNodeListCacheBase(NodeListRootType rootType, NodeListInvalidationType invalidationType)

        : m_rootedAtDocument(rootType == NodeListIsRootedAtDocument)

        , m_invalidationType(invalidationType)

43 , m_collectionType(InvalidCollectionType)

    {

        ASSERT(m_invalidationType == static_cast<unsigned>(invalidationType));

        clearCache();

    }

    DynamicNodeListCacheBase(CollectionType collectionType)

        : m_collectionType(collectionType)

    {

        ASSERT(m_collectionType == static_cast<unsigned>(collectionType));

        clearCache();

    }

public:

    ALWAYS_INLINE bool isRootedAtDocument() const { return m_rootedAtDocument; }

    ALWAYS_INLINE bool shouldInvalidateOnAttributeChange() const { return m_invalidationType != DoNotInvalidateOnAttributeChanges; }

    ALWAYS_INLINE NodeListRootType rootType() { return m_rootedAtDocument ? NodeListIsRootedAtDocument : NodeListIsRootedAtNode; }

    ALWAYS_INLINE NodeListInvalidationType invalidationType() const { return static_cast<NodeListInvalidationType>(m_invalidationType); }

61 ALWAYS_INLINE CollectionType type() const { return static_cast<CollectionType>(m_collectionType); }

protected:

    ALWAYS_INLINE bool isItemCacheValid() const { return m_isItemCacheValid; }

@@protected:

        m_isItemCacheValid = true;

    }

    bool hasNameCache() const { return m_isNameCacheValid; }

    void setHasNameCache() const { m_isNameCacheValid = true; }

    void clearCache() const

    {

        m_cachedItem = 0;

        m_isLengthCacheValid = false;

        m_isItemCacheValid = false;

91 m_isNameCacheValid = false;

    }

private:

@@private:

    // From DynamicNodeList

    const unsigned m_rootedAtDocument : 1;

    const unsigned m_invalidationType : 3;

    // From HTMLCollection

    mutable unsigned m_isNameCacheValid : 1;

    const unsigned m_collectionType : 5;

};

class DynamicNodeList : public NodeList, public DynamicNodeListCacheBase {

122519

Source/WebCore/html/HTMLCollection.cpp

@@namespace WebCore {

using namespace HTMLNames;

43 static bool shouldIncludeChildren(CollectionType type)

43static bool shouldOnlyIncludeDirectChildren(CollectionType type)

{

    switch (type) {

    case DocAll:

@@static bool shouldIncludeChildren(Collec

    case ItemProperties:

#endif

    case FormControls:

66 return ~~tru~~e;

66 return false;

    case NodeChildren:

    case TRCells:

    case TSectionRows:

    case TableTBodies:

71 return false;

        return true;

    case InvalidCollectionType:

        break;

    }

    ASSERT_NOT_REACHED();

    return false;

}

HTMLCollection::HTMLCollection(Node* base, CollectionType type)

78 : HTMLCollectionCacheBase(type~~, shouldIncludeChildren(type~~))

80 : HTMLCollectionCacheBase(type)

    , m_base(base)

{

    ASSERT(m_base);

@@inline bool HTMLCollection::isAcceptable

    case DocumentNamedItems:

    case TableRows:

    case WindowNamedItems:

175 case InvalidCollectionType:

        ASSERT_NOT_REACHED();

    }

    return false;

}

178 static Node* nextNode~~OrSibling~~(Node* base, Node* n~~ode~~, bool includeChildren)

181static ALWAYS_INLINE Node* nextNode(Node* base, Node* previous, bool onlyIncludeDirectChildren)

179182{

180 return includeChildren ? n~~ode->traverseNextNode(base) : node~~->traverseNextSibling(base);

183 return onlyIncludeDirectChildren ? previous->traverseNextSibling(base) : previous->traverseNextNode(base);

}

Element* HTMLCollection::itemAfter(unsigned& offsetInArray, Element* previous) const

{

    ASSERT_UNUSED(offsetInArray, !offsetInArray);

    Node* current;

    if (!previous)

        current = m_base->firstChild();

    else

        current = nextNodeOrSibling(base(), previous, includeChildren());

    for (; current; current = nextNodeOrSibling(base(), current, includeChildren())) {

        if (!current->isElementNode())

            continue;

        Element* element = static_cast<Element*>(current);

        if (isAcceptableElement(element))

            return element;

    bool onlyIncludeDirectChildren = shouldOnlyIncludeDirectChildren(type());

    Node* rootNode = base();

    Node* current = previous ? nextNode(rootNode, previous, onlyIncludeDirectChildren) : m_base->firstChild();

    for (; current; current = nextNode(rootNode, current, onlyIncludeDirectChildren)) {

        if (current->isElementNode() && isAcceptableElement(toElement(current)))

            return toElement(current);

    }

    return 0;

122519

Source/WebCore/html/HTMLCollection.h

@@class NodeList;

class HTMLCollectionCacheBase : public DynamicNodeListCacheBase {

public:

42 HTMLCollectionCacheBase(CollectionType type~~, bool includeChildren~~)

43 : DynamicNodeListCacheBase(~~NodeListIsRootedAtNode, DoNotInvalidateOnAttributeChanges) // These two flags are never used~~

42 HTMLCollectionCacheBase(CollectionType type)

43 : DynamicNodeListCacheBase(type)

4444 , m_cachedElementsArrayOffset(0)

4545 , m_cacheTreeVersion(0)

        , m_hasNameCache(false)

        , m_type(type)

        , m_includeChildren(includeChildren)

4946 {

50 ASSERT(static_cast<CollectionType>(m_type) == type);

5147 }

5248

53 CollectionType type() const { return static_cast<CollectionType>(m_type); }

protected:

    void clearCache(uint64_t currentDomTreeVersion) const

    {

@@protected:

        m_nameCache.clear();

        m_cachedElementsArrayOffset = 0;

        m_cacheTreeVersion = currentDomTreeVersion;

63 m_hasNameCache = false;

    }

    void setItemCache(Node* item, unsigned offset, unsigned elementsArrayOffset) const

@@protected:

    }

    unsigned cachedElementsArrayOffset() const { return m_cachedElementsArrayOffset; }

73 bool includeChildren() const { return m_includeChildren; }

    uint64_t cacheTreeVersion() const { return m_cacheTreeVersion; }

    typedef HashMap<AtomicStringImpl*, OwnPtr<Vector<Element*> > > NodeCacheMap;

@@protected:

    void appendIdCache(const AtomicString& name, Element* element) const { append(m_idCache, name, element); }

    void appendNameCache(const AtomicString& name, Element* element) const { append(m_nameCache, name, element); }

    bool hasNameCache() const { return m_hasNameCache; }

    void setHasNameCache() const { m_hasNameCache = true; }

    static void append(NodeCacheMap&, const AtomicString&, Element*);

private:

@@private:

    mutable NodeCacheMap m_nameCache;

    mutable unsigned m_cachedElementsArrayOffset;

    mutable uint64_t m_cacheTreeVersion;

    // FIXME: Move these bit flags to DynamicNodeListCacheBase to pack them better.

    mutable unsigned m_hasNameCache : 1;

    const unsigned m_type : 5; // CollectionType

    const unsigned m_includeChildren : 1;

};

class HTMLCollection : public RefCounted<HTMLCollection>, public HTMLCollectionCacheBase {

122519