[oilpan]: Avoid refcounting QualifiedName's nullQName when tracing.

Source/core/dom/QualifiedName.h

 /*
  * Copyright (C) 2005, 2006, 2009 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 16 matching lines @@
 #include "wtf/text/AtomicString.h"
 
 namespace WebCore {
 
 struct QualifiedNameComponents {
     StringImpl* m_prefix;
     StringImpl* m_localName;
     StringImpl* m_namespace;
 };
 
+// This struct is used pass data between QualifiedName and the QNameTranslator.

[haraken, 2014/06/12 10:57:15]

is used to pass

[wibling-chromium, 2014/06/12 11:02:05]

Done.

+// For hashing and equality only the QualifiedNameComponents fields are used.
+struct QualifiedNameData {
+    QualifiedNameComponents m_components;
+    bool m_isStatic;
+};
+
 class QualifiedName {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     class QualifiedNameImpl : public RefCounted<QualifiedNameImpl> {
     public:
-        static PassRefPtr<QualifiedNameImpl> create(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI)
+        static PassRefPtr<QualifiedNameImpl> create(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI, bool isStatic)
         {
-            return adoptRef(new QualifiedNameImpl(prefix, localName, namespaceURI));
+            return adoptRef(new QualifiedNameImpl(prefix, localName, namespaceURI, isStatic));
         }
 
         ~QualifiedNameImpl();
 
         unsigned computeHash() const;
 
-        mutable unsigned m_existingHash;
+        bool hasOneRef() const
+        {
+            return m_isStatic || RefCounted<QualifiedNameImpl>::hasOneRef();
+        }
+
+        void ref()
+        {
+            if (m_isStatic)
+                return;
+            RefCounted<QualifiedNameImpl>::ref();
+        }
+
+        void deref()
+        {
+            if (m_isStatic)
+                return;
+            RefCounted<QualifiedNameImpl>::deref();
+        }
+
         const AtomicString m_prefix;
         const AtomicString m_localName;
         const AtomicString m_namespace;
         mutable AtomicString m_localNameUpper;
+        // We rely on StringHasher's hashMemory clearing out the top 8 bits when
+        // doing hashing and use one of the bits for the m_isStatic value.
+        mutable unsigned m_existingHash : 24;
+        unsigned m_isStatic : 1;
 
     private:
-        QualifiedNameImpl(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI)
-            : m_existingHash(0)
-            , m_prefix(prefix)
+        QualifiedNameImpl(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI, bool isStatic)
+            : m_prefix(prefix)
             , m_localName(localName)
             , m_namespace(namespaceURI)
+            , m_existingHash(0)
+            , m_isStatic(isStatic)
+
         {
             ASSERT(!namespaceURI.isEmpty() || namespaceURI.isNull());
         }
     };
 
     QualifiedName(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI);
     ~QualifiedName();
 #ifdef QNAME_DEFAULT_CONSTRUCTOR
     QualifiedName() { }
 #endif
@@ skipping 22 matching lines @@
     // Uppercased localName, cached for efficiency
     const AtomicString& localNameUpper() const;
 
     String toString() const;
 
     QualifiedNameImpl* impl() const { return m_impl.get(); }
 
     // Init routine for globals
     static void init();
 
+    static const QualifiedName& null();
+
+    // The below methods are only for creating static global QNames that need no ref counting.
+    static void createStatic(void* targetAddress, StringImpl* name);
+    static void createStatic(void* targetAddress, StringImpl* name, const AtomicString& nameNamespace);
+
 private:
+    // This constructor is used only to create global/static QNames that don't require any ref counting.
+    QualifiedName(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI, bool isStatic);
+
     RefPtr<QualifiedNameImpl> m_impl;
 };
 
 #ifndef WEBCORE_QUALIFIEDNAME_HIDE_GLOBALS
 extern const QualifiedName anyName;
 inline const QualifiedName& anyQName() { return anyName; }
 #endif
 
-const QualifiedName& nullQName();
-
 inline bool operator==(const AtomicString& a, const QualifiedName& q) { return a == q.localName(); }
 inline bool operator!=(const AtomicString& a, const QualifiedName& q) { return a != q.localName(); }
 inline bool operator==(const QualifiedName& q, const AtomicString& a) { return a == q.localName(); }
 inline bool operator!=(const QualifiedName& q, const AtomicString& a) { return a != q.localName(); }
 
 inline unsigned hashComponents(const QualifiedNameComponents& buf)
 {
     return StringHasher::hashMemory<sizeof(QualifiedNameComponents)>(&buf);
 }
 
 struct QualifiedNameHash {
     static unsigned hash(const QualifiedName& name) { return hash(name.impl()); }
 
     static unsigned hash(const QualifiedName::QualifiedNameImpl* name)
     {
         if (!name->m_existingHash)
             name->m_existingHash = name->computeHash();
         return name->m_existingHash;
     }
 
     static bool equal(const QualifiedName& a, const QualifiedName& b) { return a == b; }
     static bool equal(const QualifiedName::QualifiedNameImpl* a, const QualifiedName::QualifiedNameImpl* b) { return a == b; }
 
     static const bool safeToCompareToEmptyOrDeleted = false;
 };
 
-void createQualifiedName(void* targetAddress, StringImpl* name);
-void createQualifiedName(void* targetAddress, StringImpl* name, const AtomicString& nameNamespace);
-
 }
 
 namespace WTF {
 
     template<typename T> struct DefaultHash;
 
     template<> struct DefaultHash<WebCore::QualifiedName> {
         typedef WebCore::QualifiedNameHash Hash;
     };
 
     template<> struct HashTraits<WebCore::QualifiedName> : SimpleClassHashTraits<WebCore::QualifiedName> {
         static const bool emptyValueIsZero = false;
-        static WebCore::QualifiedName emptyValue() { return WebCore::nullQName(); }
+        static WebCore::QualifiedName emptyValue() { return WebCore::QualifiedName::null(); }
     };
 }
 
 #endif