Oilpan: Improve Oilpan support in EventContext and EventPath.

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 @@
             || eventType == EventTypeNames::resize
             || eventType == EventTypeNames::scroll
             || eventType == EventTypeNames::select
             || eventType == EventTypeNames::selectstart))
         return StayInsideShadowDOM;
 
     return RetargetEvent;
 }
 
 EventPath::EventPath(Event* event)
-    : m_node(0)
+    : m_node(nullptr)
     , m_event(event)
 {
 }
 
 EventPath::EventPath(Node* node)
     : m_node(node)
     , m_event(nullptr)
 {
     resetWith(node);
 }
@@ skipping 12 matching lines @@
 
 void EventPath::addNodeEventContext(Node* node)
 {
     m_nodeEventContexts.append(NodeEventContext(node, eventTargetRespectingTargetRules(node)));
 }
 
 void EventPath::calculatePath()
 {
     ASSERT(m_node);
     ASSERT(m_nodeEventContexts.isEmpty());
-    m_node->document().updateDistributionForNodeIfNeeded(const_cast<Node*>(m_node));
+    m_node->document().updateDistributionForNodeIfNeeded(const_cast<Node*>(m_node.get()));
 
     Node* current = m_node;
     addNodeEventContext(current);
     if (!m_node->inDocument())
         return;
     while (current) {
         if (current->isShadowRoot() && m_event && determineDispatchBehavior(m_event, toShadowRoot(current), m_node) == StayInsideShadowDOM)
             break;
         WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
         collectDestinationInsertionPoints(*current, insertionPoints);
@@ skipping 20 matching lines @@
                 addNodeEventContext(current);
         }
     }
 }
 
 void EventPath::calculateTreeScopePrePostOrderNumbers()
 {
     // Precondition:
     //   - TreeScopes in m_treeScopeEventContexts must be *connected* in the same tree of trees.
     //   - The root tree must be included.
-    HashMap<const TreeScope*, TreeScopeEventContext*> treeScopeEventContextMap;
+    WillBeHeapHashMap<RawPtrWillBeMember<const TreeScope>, RawPtrWillBeMember<TreeScopeEventContext> > treeScopeEventContextMap;
     for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i)
         treeScopeEventContextMap.add(&m_treeScopeEventContexts[i]->treeScope(), m_treeScopeEventContexts[i].get());
     TreeScopeEventContext* rootTree = 0;
     for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
         TreeScopeEventContext* treeScopeEventContext = m_treeScopeEventContexts[i].get();
         // Use olderShadowRootOrParentTreeScope here for parent-child relationships.
         // See the definition of trees of trees in the Shado DOM spec: http://w3c.github.io/webcomponents/spec/shadow/
         TreeScope* parent = treeScopeEventContext->treeScope().olderShadowRootOrParentTreeScope();
         if (!parent) {
             ASSERT(!rootTree);
@@ skipping 66 matching lines @@
 {
     EventPath relatedTargetEventPath(const_cast<Node*>(relatedNode));
     for (size_t i = 0; i < relatedTargetEventPath.m_treeScopeEventContexts.size(); ++i) {
         TreeScopeEventContext* treeScopeEventContext = relatedTargetEventPath.m_treeScopeEventContexts[i].get();
         relatedTargetMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext->target());
     }
 }
 
 EventTarget* EventPath::findRelatedNode(TreeScope* scope, RelatedTargetMap& relatedTargetMap)
 {
-    Vector<TreeScope*, 32> parentTreeScopes;
+    WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 32> parentTreeScopes;
     EventTarget* relatedNode = 0;
     while (scope) {
         parentTreeScopes.append(scope);
         RelatedTargetMap::const_iterator iter = relatedTargetMap.find(scope);
         if (iter != relatedTargetMap.end() && iter->value) {
             relatedNode = iter->value;
             break;
         }
         scope = scope->olderShadowRootOrParentTreeScope();
     }
     ASSERT(relatedNode);
-    for (Vector<TreeScope*, 32>::iterator iter = parentTreeScopes.begin(); iter < parentTreeScopes.end(); ++iter)
+    for (WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 32>::iterator iter = parentTreeScopes.begin(); iter < parentTreeScopes.end(); ++iter)
         relatedTargetMap.add(*iter, relatedNode);
     return relatedNode;
 }
 
 void EventPath::adjustForRelatedTarget(Node* target, EventTarget* relatedTarget)
 {
     if (!target)
         return;
     if (!relatedTarget)
         return;
@@ skipping 35 matching lines @@
             break;
         }
     }
 }
 
 void EventPath::adjustForTouchEvent(Node* node, TouchEvent& touchEvent)
 {
     WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTouches;
     WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTargetTouches;
     WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedChangedTouches;
-    Vector<TreeScope*> treeScopes;
+    WillBeHeapVector<RawPtrWillBeMember<TreeScope> > treeScopes;
 
     for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
         TouchEventContext* touchEventContext = m_treeScopeEventContexts[i]->ensureTouchEventContext();
         adjustedTouches.append(&touchEventContext->touches());
         adjustedTargetTouches.append(&touchEventContext->targetTouches());
         adjustedChangedTouches.append(&touchEventContext->changedTouches());
         treeScopes.append(&m_treeScopeEventContexts[i]->treeScope());
     }
 
     adjustTouchList(node, touchEvent.touches(), adjustedTouches, treeScopes);
     adjustTouchList(node, touchEvent.targetTouches(), adjustedTargetTouches, treeScopes);
     adjustTouchList(node, touchEvent.changedTouches(), adjustedChangedTouches, treeScopes);
 
 #ifndef NDEBUG
     for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
         TreeScope& treeScope = m_treeScopeEventContexts[i]->treeScope();
         TouchEventContext* touchEventContext = m_treeScopeEventContexts[i]->touchEventContext();
         checkReachability(treeScope, touchEventContext->touches());
         checkReachability(treeScope, touchEventContext->targetTouches());
         checkReachability(treeScope, touchEventContext->changedTouches());
     }
 #endif
 }
 
-void EventPath::adjustTouchList(const Node* node, const TouchList* touchList, WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTouchList, const Vector<TreeScope*>& treeScopes)
+void EventPath::adjustTouchList(const Node* node, const TouchList* touchList, WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTouchList, const WillBeHeapVector<RawPtrWillBeMember<TreeScope> >& treeScopes)
 {
     if (!touchList)
         return;
     for (size_t i = 0; i < touchList->length(); ++i) {
         const Touch& touch = *touchList->item(i);
         RelatedTargetMap relatedNodeMap;
         buildRelatedNodeMap(touch.target()->toNode(), relatedNodeMap);
         for (size_t j = 0; j < treeScopes.size(); ++j) {
             adjustedTouchList[j]->append(touch.cloneWithNewTarget(findRelatedNode(treeScopes[j], relatedNodeMap)));
         }
     }
 }
 
 #ifndef NDEBUG
 void EventPath::checkReachability(TreeScope& treeScope, TouchList& touchList)
 {
     for (size_t i = 0; i < touchList.length(); ++i)
         ASSERT(touchList.item(i)->target()->toNode()->treeScope().isInclusiveOlderSiblingShadowRootOrAncestorTreeScopeOf(treeScope));
 }
 #endif
 
 void EventPath::trace(Visitor* visitor)
 {
     visitor->trace(m_nodeEventContexts);
+    visitor->trace(m_node);
     visitor->trace(m_event);
+    visitor->trace(m_treeScopeEventContexts);
 }
 
 } // namespace