Changeset 238504 in webkit


Ignore:
Timestamp:
Nov 26, 2018 11:29:23 AM (5 years ago)
Author:
commit-queue@webkit.org
Message:

Streamline ListHashSet use in floating object code
​https://bugs.webkit.org/show_bug.cgi?id=191957

Patch by Sam Weinig <​sam@webkit.org> on 2018-11-26
Reviewed by Alex Christensen.

Source/WebCore:

Simplify use of ListHashSet by using new raw pointer overloads and
making use of reversed order of template arguments in the find() and
contains() overloads that take hash translators.

  • rendering/FloatingObjects.cpp:

(WebCore::FloatingObjects::remove):
Use raw pointer overloads of contains and remove. Remove seperate call
to find / check agains end() which is unnecessary as remove() already
does that.

  • rendering/FloatingObjects.h:

(WebCore::FloatingObjectHashFunctions::hash):
(WebCore::FloatingObjectHashFunctions::equal):
(WebCore::FloatingObjectHashTranslator::hash):
(WebCore::FloatingObjectHashTranslator::equal):
Add hash()/equal() overloads for the raw pointer cases. As the FIXME
notes, this could be simplified by changing PtrHashBase to use designated
bottleneck functions for hash() and equal().

  • rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::containsFloat const):
(WebCore::RenderBlockFlow::insertFloatingObject):
(WebCore::RenderBlockFlow::removeFloatingObject):
(WebCore::RenderBlockFlow::hasOverhangingFloat):
(WebCore::RenderBlockFlow::addIntrudingFloats):
Use simplified calls.

  • rendering/RenderBlockLineLayout.cpp:

(WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
(WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
Use simplified calls.

Source/WTF:

  • wtf/ListHashSet.h:

Reverses the order of the template arguments for the find() and contains()
overload that allow specifying a hash translator to allow the compiler to
deduce type T. This simplifies call sites and matches other WTF containers.

Location:
trunk/Source
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r238478 r238504  
     12018-11-26  Sam Weinig  <sam@webkit.org>
     2
     3        Streamline ListHashSet use in floating object code
     4        https://bugs.webkit.org/show_bug.cgi?id=191957
     5
     6        Reviewed by Alex Christensen.
     7
     8        * wtf/ListHashSet.h:
     9        Reverses the order of the template arguments for the find() and contains()
     10        overload that allow specifying a hash translator to allow the compiler to
     11        deduce type T. This simplifies call sites and matches other WTF containers.
     12
    1132018-11-25  Michael Catanzaro  <mcatanzaro@igalia.com>
    214

  • trunk/Source/WTF/wtf/ListHashSet.h

    r238467 r238504  
    113113    // with some other type, to avoid the cost of type conversion.
    114114    // The HashTranslator interface is defined in HashSet.
    115     // FIXME: We should reverse the order of the template arguments so that callers
    116     // can just pass the translator let the compiler deduce T.
    117     template<typename T, typename HashTranslator> iterator find(const T&);
    118     template<typename T, typename HashTranslator> const_iterator find(const T&) const;
    119     template<typename T, typename HashTranslator> bool contains(const T&) const;
     115    template<typename HashTranslator, typename T> iterator find(const T&);
     116    template<typename HashTranslator, typename T> const_iterator find(const T&) const;
     117    template<typename HashTranslator, typename T> bool contains(const T&) const;
    120118
    121119    // The return value of add is a pair of an iterator to the new value's location,
    … …  
    481479
    482480template<typename ValueType, typename U>
    483 template<typename T, typename HashTranslator>
     481template<typename HashTranslator, typename T>
    484482inline auto ListHashSet<ValueType, U>::find(const T& value) -> iterator
    485483{
    … …  
    491489
    492490template<typename ValueType, typename U>
    493 template<typename T, typename HashTranslator>
     491template<typename HashTranslator, typename T>
    494492inline auto ListHashSet<ValueType, U>::find(const T& value) const -> const_iterator
    495493{
    … …  
    501499
    502500template<typename ValueType, typename U>
    503 template<typename T, typename HashTranslator>
     501template<typename HashTranslator, typename T>
    504502inline bool ListHashSet<ValueType, U>::contains(const T& value) const
    505503{

  • trunk/Source/WebCore/ChangeLog

    r238503 r238504  
     12018-11-26  Sam Weinig  <sam@webkit.org>
     2
     3        Streamline ListHashSet use in floating object code
     4        https://bugs.webkit.org/show_bug.cgi?id=191957
     5
     6        Reviewed by Alex Christensen.
     7
     8        Simplify use of ListHashSet by using new raw pointer overloads and
     9        making use of reversed order of template arguments in the find() and
     10        contains() overloads that take hash translators. 
     11
     12        * rendering/FloatingObjects.cpp:
     13        (WebCore::FloatingObjects::remove):
     14        Use raw pointer overloads of contains and remove. Remove seperate call
     15        to find / check agains end() which is unnecessary as remove() already
     16        does that.
     17       
     18        * rendering/FloatingObjects.h:
     19        (WebCore::FloatingObjectHashFunctions::hash):
     20        (WebCore::FloatingObjectHashFunctions::equal):
     21        (WebCore::FloatingObjectHashTranslator::hash):
     22        (WebCore::FloatingObjectHashTranslator::equal):
     23        Add hash()/equal() overloads for the raw pointer cases. As the FIXME
     24        notes, this could be simplified by changing PtrHashBase to use designated
     25        bottleneck functions for hash() and equal().
     26
     27        * rendering/RenderBlockFlow.cpp:
     28        (WebCore::RenderBlockFlow::containsFloat const):
     29        (WebCore::RenderBlockFlow::insertFloatingObject):
     30        (WebCore::RenderBlockFlow::removeFloatingObject):
     31        (WebCore::RenderBlockFlow::hasOverhangingFloat):
     32        (WebCore::RenderBlockFlow::addIntrudingFloats):
     33        Use simplified calls.
     34       
     35        * rendering/RenderBlockLineLayout.cpp:
     36        (WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
     37        (WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
     38        Use simplified calls.
     39
    1402018-11-26  Jeremy Jones  <jeremyj@apple.com>
    241

  • trunk/Source/WebCore/rendering/FloatingObjects.cpp

    r238463 r238504  
    349349void FloatingObjects::remove(FloatingObject* floatingObject)
    350350{
    351     ASSERT((m_set.contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)));
     351    ASSERT((m_set.contains(floatingObject)));
    352352    decreaseObjectsCount(floatingObject->type());
    353353    ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
    … …  
    355355        removePlacedObject(floatingObject);
    356356    ASSERT(!floatingObject->originatingLine());
    357     auto it = m_set.find<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject);
    358     if (it == m_set.end())
    359         return;
    360     m_set.remove(it);
     357    m_set.remove(floatingObject);
    361358}
    362359

  • trunk/Source/WebCore/rendering/FloatingObjects.h

    r235315 r238504  
    112112};
    113113
     114// FIXME: This could be simplified if we made it inherit from PtrHash<std::unique_ptr<FloatingObject>> and
     115// changed PtrHashBase to have all of its hash and equal functions bottleneck through single functions (as
     116// is done here). That would allow us to only override those master hash and equal functions.
    114117struct FloatingObjectHashFunctions {
    115     static unsigned hash(const std::unique_ptr<FloatingObject>& key) { return PtrHash<RenderBox*>::hash(&key->renderer()); }
    116     static bool equal(const std::unique_ptr<FloatingObject>& a, const std::unique_ptr<FloatingObject>& b) { return &a->renderer() == &b->renderer(); }
     118    typedef std::unique_ptr<FloatingObject> T;
     119    typedef typename WTF::GetPtrHelper<T>::PtrType PtrType;
     120
     121    static unsigned hash(PtrType key) { return PtrHash<RenderBox*>::hash(&key->renderer()); }
     122    static bool equal(PtrType a, PtrType b) { return &a->renderer() == &b->renderer(); }
    117123    static const bool safeToCompareToEmptyOrDeleted = true;
     124
     125    static unsigned hash(const T& key) { return hash(WTF::getPtr(key)); }
     126    static bool equal(const T& a, const T& b) { return equal(WTF::getPtr(a), WTF::getPtr(b)); }
     127    static bool equal(PtrType a, const T& b) { return equal(a, WTF::getPtr(b)); }
     128    static bool equal(const T& a, PtrType b) { return equal(WTF::getPtr(a), b); }
    118129};
    119130struct FloatingObjectHashTranslator {
    120131    static unsigned hash(const RenderBox& key) { return PtrHash<const RenderBox*>::hash(&key); }
    121     static unsigned hash(const FloatingObject& key) { return PtrHash<RenderBox*>::hash(&key.renderer()); }
    122132    static bool equal(const std::unique_ptr<FloatingObject>& a, const RenderBox& b) { return &a->renderer() == &b; }
    123     static bool equal(const std::unique_ptr<FloatingObject>& a, const FloatingObject& b) { return &a->renderer() == &b.renderer(); }
    124133};
    125134

  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r238463 r238504  
    19861986bool RenderBlockFlow::containsFloat(RenderBox& renderer) const
    19871987{
    1988     return m_floatingObjects && m_floatingObjects->set().contains<RenderBox&, FloatingObjectHashTranslator>(renderer);
     1988    return m_floatingObjects && m_floatingObjects->set().contains<FloatingObjectHashTranslator>(renderer);
    19891989}
    19901990
    … …  
    22342234        // Don't insert the floatingObject again if it's already in the list
    22352235        const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
    2236         auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(floatBox);
     2236        auto it = floatingObjectSet.find<FloatingObjectHashTranslator>(floatBox);
    22372237        if (it != floatingObjectSet.end())
    22382238            return it->get();
    … …  
    22682268    if (m_floatingObjects) {
    22692269        const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
    2270         auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(floatBox);
     2270        auto it = floatingObjectSet.find<FloatingObjectHashTranslator>(floatBox);
    22712271        if (it != floatingObjectSet.end()) {
    22722272            auto& floatingObject = *it->get();
    … …  
    26842684
    26852685    const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
    2686     const auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(renderer);
     2686    const auto it = floatingObjectSet.find<FloatingObjectHashTranslator>(renderer);
    26872687    if (it == floatingObjectSet.end())
    26882688        return false;
    … …  
    27102710        auto& floatingObject = *prevIt->get();
    27112711        if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
    2712             if (!m_floatingObjects || !m_floatingObjects->set().contains<FloatingObject&, FloatingObjectHashTranslator>(floatingObject)) {
     2712            if (!m_floatingObjects || !m_floatingObjects->set().contains(&floatingObject)) {
    27132713                // We create the floating object list lazily.
    27142714                if (!m_floatingObjects)

  • trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

    r238463 r238504  
    14581458            auto end = floatingObjectSet.end();
    14591459            if (auto* lastFloat = layoutState.floatList().lastFloat()) {
    1460                 auto lastFloatIterator = floatingObjectSet.find<FloatingObject&, FloatingObjectHashTranslator>(*lastFloat);
     1460                auto lastFloatIterator = floatingObjectSet.find(lastFloat);
    14611461                ASSERT(lastFloatIterator != end);
    14621462                ++lastFloatIterator;
    … …  
    16211621        auto end = floatingObjectSet.end();
    16221622        if (auto* lastFloat = layoutState.floatList().lastFloat()) {
    1623             auto lastFloatIterator = floatingObjectSet.find<FloatingObject&, FloatingObjectHashTranslator>(*lastFloat);
     1623            auto lastFloatIterator = floatingObjectSet.find(lastFloat);
    16241624            ASSERT(lastFloatIterator != end);
    16251625            ++lastFloatIterator;
Note: See TracChangeset for help on using the changeset viewer.