Oilpan: Remove most WillBe types from the code base

third_party/WebKit/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 81 matching lines @@
 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;
+    HeapVector<Member<Node>, 64> nodesInPath;
     Node* current = m_node;
     nodesInPath.append(current);
     while (current) {
         if (m_event && current->keepEventInNode(m_event))
             break;
-        WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
+        HeapVector<Member<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())
                         nodesInPath.append(containingShadowRoot->olderShadowRoot());
                 }
                 nodesInPath.append(insertionPoint);
@@ skipping 33 matching lines @@
     for (Node* nodeInPath : nodesInPath) {
         m_nodeEventContexts.append(NodeEventContext(nodeInPath, eventTargetRespectingTargetRules(*nodeInPath)));
     }
 }
 
 void EventPath::calculateTreeOrderAndSetNearestAncestorClosedTree()
 {
     // Precondition:
     //   - TreeScopes in m_treeScopeEventContexts must be *connected* in the same composed tree.
     //   - The root tree must be included.
-    WillBeHeapHashMap<RawPtrWillBeMember<const TreeScope>, RawPtrWillBeMember<TreeScopeEventContext>> treeScopeEventContextMap;
+    HeapHashMap<Member<const TreeScope>, Member<TreeScopeEventContext>> treeScopeEventContextMap;
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts)
         treeScopeEventContextMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext.get());
     TreeScopeEventContext* rootTree = nullptr;
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         // Use olderShadowRootOrParentTreeScope here for parent-child relationships.
         // See the definition of trees of trees in the Shadow DOM spec:
         // http://w3c.github.io/webcomponents/spec/shadow/
         TreeScope* parent = treeScopeEventContext.get()->treeScope().olderShadowRootOrParentTreeScope();
         if (!parent) {
             ASSERT(!rootTree);
@@ skipping 48 matching lines @@
         }
         ASSERT(lastTreeScopeEventContext);
         at(i).setTreeScopeEventContext(lastTreeScopeEventContext);
         lastTreeScope = &currentTreeScope;
     }
     m_treeScopeEventContexts.appendRange(treeScopeEventContextMap.values().begin(), treeScopeEventContextMap.values().end());
 }
 
 void EventPath::buildRelatedNodeMap(const Node& relatedNode, RelatedTargetMap& relatedTargetMap)
 {
-    OwnPtrWillBeRawPtr<EventPath> relatedTargetEventPath = adoptPtrWillBeNoop(new EventPath(const_cast<Node&>(relatedNode)));
+    RawPtr<EventPath> relatedTargetEventPath = new EventPath(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());
     }
 #if ENABLE(OILPAN)
     // Oilpan: It is important to explicitly clear the vectors to reuse
     // the memory in subsequent event dispatchings.
     relatedTargetEventPath->clear();
 #endif
 }
 
 EventTarget* EventPath::findRelatedNode(TreeScope& scope, RelatedTargetMap& relatedTargetMap)
 {
-    WillBeHeapVector<RawPtrWillBeMember<TreeScope>, 32> parentTreeScopes;
+    HeapVector<Member<TreeScope>, 32> parentTreeScopes;
     EventTarget* relatedNode = nullptr;
     for (TreeScope* current = &scope; current; current = current->olderShadowRootOrParentTreeScope()) {
         parentTreeScopes.append(current);
         RelatedTargetMap::const_iterator iter = relatedTargetMap.find(current);
         if (iter != relatedTargetMap.end() && iter->value) {
             relatedNode = iter->value;
             break;
         }
     }
     ASSERT(relatedNode);
@@ skipping 41 matching lines @@
         } else if (at(i).target() == at(i).relatedTarget()) {
             // Event dispatching should be stopped here.
             shrink(i);
             break;
         }
     }
 }
 
 void EventPath::adjustForTouchEvent(TouchEvent& touchEvent)
 {
-    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedTargetTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedChangedTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TreeScope>> treeScopes;
+    HeapVector<Member<TouchList>> adjustedTouches;
+    HeapVector<Member<TouchList>> adjustedTargetTouches;
+    HeapVector<Member<TouchList>> adjustedChangedTouches;
+    HeapVector<Member<TreeScope>> treeScopes;
 
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         TouchEventContext* touchEventContext = treeScopeEventContext->ensureTouchEventContext();
         adjustedTouches.append(&touchEventContext->touches());
         adjustedTargetTouches.append(&touchEventContext->targetTouches());
         adjustedChangedTouches.append(&touchEventContext->changedTouches());
         treeScopes.append(&treeScopeEventContext->treeScope());
     }
 
     adjustTouchList(touchEvent.touches(), adjustedTouches, treeScopes);
     adjustTouchList(touchEvent.targetTouches(), adjustedTargetTouches, treeScopes);
     adjustTouchList(touchEvent.changedTouches(), adjustedChangedTouches, treeScopes);
 
 #if ENABLE(ASSERT)
     for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         TreeScope& treeScope = treeScopeEventContext->treeScope();
         TouchEventContext* touchEventContext = treeScopeEventContext->touchEventContext();
         checkReachability(treeScope, touchEventContext->touches());
         checkReachability(treeScope, touchEventContext->targetTouches());
         checkReachability(treeScope, touchEventContext->changedTouches());
     }
 #endif
 }
 
-void EventPath::adjustTouchList(const TouchList* touchList, WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedTouchList, const WillBeHeapVector<RawPtrWillBeMember<TreeScope>>& treeScopes)
+void EventPath::adjustTouchList(const TouchList* touchList, HeapVector<Member<TouchList>> adjustedTouchList, const HeapVector<Member<TreeScope>>& treeScopes)
 {
     if (!touchList)
         return;
     for (size_t i = 0; i < touchList->length(); ++i) {
         const Touch& touch = *touchList->item(i);
         if (!touch.target())
             continue;
 
         Node* targetNode = touch.target()->toNode();
         if (!targetNode)
@@ skipping 10 matching lines @@
 const NodeEventContext& EventPath::topNodeEventContext()
 {
     ASSERT(!isEmpty());
     return last();
 }
 
 void EventPath::ensureWindowEventContext()
 {
     ASSERT(m_event);
     if (!m_windowEventContext)
-        m_windowEventContext = adoptPtrWillBeNoop(new WindowEventContext(*m_event, topNodeEventContext()));
+        m_windowEventContext = new WindowEventContext(*m_event, topNodeEventContext());
 }
 
 #if ENABLE(ASSERT)
 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
 
 DEFINE_TRACE(EventPath)
 {
 #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 blink