[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 49 matching lines @@
             , m_prefix(prefix)
             , m_localName(localName)
             , m_namespace(namespaceURI)
         {
             ASSERT(!namespaceURI.isEmpty() || namespaceURI.isNull());
         }
     };
 
     QualifiedName(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI);
     ~QualifiedName();
-#ifdef QNAME_DEFAULT_CONSTRUCTOR
-    QualifiedName() { }
-#endif
+    QualifiedName() : m_impl(nullptr) { }
 
     QualifiedName(const QualifiedName& other) : m_impl(other.m_impl) { }
     const QualifiedName& operator=(const QualifiedName& other) { m_impl = other.m_impl; return *this; }
 
     // Hash table deleted values, which are only constructed and never copied or destroyed.
     QualifiedName(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { }
     bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
 
     bool operator==(const QualifiedName& other) const { return m_impl == other.m_impl; }
     bool operator!=(const QualifiedName& other) const { return !(*this == other); }
 
     bool matches(const QualifiedName& other) const { return m_impl == other.m_impl || (localName() == other.localName() && namespaceURI() == other.namespaceURI()); }
 
     bool matchesPossiblyIgnoringCase(const QualifiedName& other, bool shouldIgnoreCase) const { return m_impl == other.m_impl || (equalPossiblyIgnoringCase(localName(), other.localName(), shouldIgnoreCase) && namespaceURI() == other.namespaceURI()); }
 
-    bool hasPrefix() const { return m_impl->m_prefix != nullAtom; }
+    bool hasPrefix() const { return m_impl ? (m_impl->m_prefix != nullAtom) : false; }

[esprehn, 2014/06/05 00:58:44]

Don't use a ternary, use &&.

return m_impl && m_impl->m_prefix != nullAtom;

     void setPrefix(const AtomicString& prefix) { *this = QualifiedName(prefix, localName(), namespaceURI()); }
 
-    const AtomicString& prefix() const { return m_impl->m_prefix; }
-    const AtomicString& localName() const { return m_impl->m_localName; }
-    const AtomicString& namespaceURI() const { return m_impl->m_namespace; }
+    const AtomicString& prefix() const { return m_impl ? m_impl->m_prefix : nullAtom; }
+    const AtomicString& localName() const { return m_impl ? m_impl->m_localName : nullAtom; }
+    const AtomicString& namespaceURI() const { return m_impl ? m_impl->m_namespace : nullAtom; }

[esprehn, 2014/06/05 00:58:44]

This code can all be really hot, we call into it all over selector checking and
other things. Are we sure we want branches inside it?

 
     // Uppercased localName, cached for efficiency
     const AtomicString& localNameUpper() const;
 
     String toString() const;
 
-    QualifiedNameImpl* impl() const { return m_impl.get(); }
+    QualifiedNameImpl* impl() const { return m_impl ? m_impl.get() : 0; }

[esprehn, 2014/06/05 00:58:44]

The ternary is not needed here.

+    bool isNull() const { return !m_impl; }
 
     // Init routine for globals
     static void init();
 
 private:
     RefPtr<QualifiedNameImpl> m_impl;
 };
 
 #ifndef WEBCORE_QUALIFIEDNAME_HIDE_GLOBALS
 extern const QualifiedName anyName;
@@ skipping 35 matching lines @@
 
 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 const bool hasIsEmptyValueFunction = true;
+        static bool isEmptyValue(const WebCore::QualifiedName& q) { return q.isNull(); }
     };
 }
 
 #endif