Shrinking EventPath to improve memory usage and performance

Source/core/events/EventPath.cpp

 /*
  * Copyright (C) 2013 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 70 matching lines @@
     initialize();
 }
 
 void EventPath::initialize()
 {
     calculatePath();
     calculateAdjustedTargets();
     calculateTreeScopePrePostOrderNumbers();
 }
 
-void EventPath::addNodeEventContext(Node& node)
-{
-    m_nodeEventContexts.append(NodeEventContext(&node, eventTargetRespectingTargetRules(node)));
-}
-
 void EventPath::calculatePath()
 {
     ASSERT(m_node);
     ASSERT(m_nodeEventContexts.isEmpty());
     m_node->updateDistribution();
 
+    // For performance and memory usage reasons we want to store the
+    // path using as few bytes as possible and with as few allocations
+    // as possible which is why we gather the data on the stack before
+    // storing it in a perfectly sized m_nodeEventContexts Vector.
+    WillBeHeapVector<RawPtrWillBeMember<Node>, 64> nodesInPath;
     Node* current = m_node;
-    addNodeEventContext(*current);
+    nodesInPath.append(current);
     if (!m_node->inDocument())
-        return;
+        current = nullptr;
     while (current) {
         if (m_event && current->keepEventInNode(m_event))
             break;
         WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
         collectDestinationInsertionPoints(*current, insertionPoints);
         if (!insertionPoints.isEmpty()) {
             for (const auto& insertionPoint : insertionPoints) {
                 if (insertionPoint->isShadowInsertionPoint()) {
                     ShadowRoot* containingShadowRoot = insertionPoint->containingShadowRoot();
                     ASSERT(containingShadowRoot);
                     if (!containingShadowRoot->isOldest())
-                        addNodeEventContext(*containingShadowRoot->olderShadowRoot());
+                        nodesInPath.append(containingShadowRoot->olderShadowRoot());
                 }
-                addNodeEventContext(*insertionPoint);
+                nodesInPath.append(insertionPoint);
             }
             current = insertionPoints.last();
             continue;
         }
         if (current->isShadowRoot()) {
             if (m_event && shouldStopAtShadowRoot(*m_event, *toShadowRoot(current), *m_node))
                 break;
             current = current->shadowHost();
-            addNodeEventContext(*current);
+            nodesInPath.append(current);
         } else {
             current = current->parentNode();
             if (current)
-                addNodeEventContext(*current);
+                nodesInPath.append(current);
         }
     }
+
+    m_nodeEventContexts.reserveCapacity(nodesInPath.size());
+    for (Node* nodeInPath : nodesInPath) {
+        m_nodeEventContexts.append(NodeEventContext(nodeInPath, eventTargetRespectingTargetRules(*nodeInPath)));
+    }
 }
 
 void EventPath::calculateTreeScopePrePostOrderNumbers()
 {
     // Precondition:
     //   - TreeScopes in m_treeScopeEventContexts must be *connected* in the same tree of trees.
     //   - The root tree must be included.
     WillBeHeapHashMap<RawPtrWillBeMember<const TreeScope>, RawPtrWillBeMember<TreeScopeEventContext>> treeScopeEventContextMap;
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts)
         treeScopeEventContextMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext.get());
@@ skipping 205 matching lines @@
 #if ENABLE(OILPAN)
     visitor->trace(m_nodeEventContexts);
     visitor->trace(m_node);
     visitor->trace(m_event);
     visitor->trace(m_treeScopeEventContexts);
     visitor->trace(m_windowEventContext);
 #endif
 }
 
 } // namespace