Use C++11 range-based loop in core/events

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 93 matching lines @@
     Node* current = m_node;
     addNodeEventContext(current);
     if (!m_node->inDocument())
         return;
     while (current) {
         if (m_event && current->keepEventInNode(m_event))
             break;
         WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
         collectDestinationInsertionPoints(*current, insertionPoints);
         if (!insertionPoints.isEmpty()) {
-            for (size_t i = 0; i < insertionPoints.size(); ++i) {
-                InsertionPoint* insertionPoint = insertionPoints[i];
+            for (const auto& insertionPoint : insertionPoints) {
                 if (insertionPoint->isShadowInsertionPoint()) {
                     ShadowRoot* containingShadowRoot = insertionPoint->containingShadowRoot();
                     ASSERT(containingShadowRoot);
                     if (!containingShadowRoot->isOldest())
                         addNodeEventContext(containingShadowRoot->olderShadowRoot());
                 }
                 addNodeEventContext(insertionPoint);
             }
             current = insertionPoints.last();
             continue;
         }
         if (current->isShadowRoot()) {
             if (m_event && shouldStopAtShadowRoot(*m_event, *toShadowRoot(current), *m_node))
                 break;
             current = current->shadowHost();
             addNodeEventContext(current);
         } else {
             current = current->parentNode();
             if (current)
                 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.
-    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());
+    WillBeHeapHashMap<RawPtrWillBeMember<const TreeScope>, RawPtrWillBeMember<TreeScopeEventContext>> treeScopeEventContextMap;
+    for (const auto& treeScopeEventContext : m_treeScopeEventContexts)
+        treeScopeEventContextMap.add(&treeScopeEventContext->treeScope(), treeScopeEventContext.get());
     TreeScopeEventContext* rootTree = 0;
-    for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
-        TreeScopeEventContext* treeScopeEventContext = m_treeScopeEventContexts[i].get();
+    for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
         // 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();
+        TreeScope* parent = treeScopeEventContext.get()->treeScope().olderShadowRootOrParentTreeScope();
         if (!parent) {
             ASSERT(!rootTree);
-            rootTree = treeScopeEventContext;
+            rootTree = treeScopeEventContext.get();
             continue;
         }
         ASSERT(treeScopeEventContextMap.find(parent) != treeScopeEventContextMap.end());
-        treeScopeEventContextMap.find(parent)->value->addChild(*treeScopeEventContext);
+        treeScopeEventContextMap.find(parent)->value->addChild(*treeScopeEventContext.get());
     }
     ASSERT(rootTree);
     rootTree->calculatePrePostOrderNumber(0);
 }
 
 TreeScopeEventContext* EventPath::ensureTreeScopeEventContext(Node* currentTarget, TreeScope* treeScope, TreeScopeEventContextMap& treeScopeEventContextMap)
 {
     if (!treeScope)
         return 0;
     TreeScopeEventContext* treeScopeEventContext;
@@ skipping 76 matching lines @@
     if (!relatedNode)
         return;
     if (target->document() != relatedNode->document())
         return;
     if (!target->inDocument() || !relatedNode->inDocument())
         return;
 
     RelatedTargetMap relatedNodeMap;
     buildRelatedNodeMap(relatedNode, relatedNodeMap);
 
-    for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
-        TreeScopeEventContext* treeScopeEventContext = m_treeScopeEventContexts[i].get();
-        EventTarget* adjustedRelatedTarget = findRelatedNode(&treeScopeEventContext->treeScope(), relatedNodeMap);
+    for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
+        EventTarget* adjustedRelatedTarget = findRelatedNode(&treeScopeEventContext.get()->treeScope(), relatedNodeMap);
         ASSERT(adjustedRelatedTarget);
-        treeScopeEventContext->setRelatedTarget(adjustedRelatedTarget);
+        treeScopeEventContext.get()->setRelatedTarget(adjustedRelatedTarget);
     }
 
     shrinkIfNeeded(target, relatedTarget);
 }
 
 void EventPath::shrinkIfNeeded(const Node* target, const EventTarget* relatedTarget)
 {
     // Synthetic mouse events can have a relatedTarget which is identical to the target.
     bool targetIsIdenticalToToRelatedTarget = (target == relatedTarget);
 
     for (size_t i = 0; i < size(); ++i) {
         if (targetIsIdenticalToToRelatedTarget) {
             if (target->treeScope().rootNode() == at(i).node()) {
                 shrink(i + 1);
                 break;
             }
         } else if (at(i).target() == at(i).relatedTarget()) {
             // Event dispatching should be stopped here.
             shrink(i);
             break;
         }
     }
 }
 
 void EventPath::adjustForTouchEvent(Node* node, TouchEvent& touchEvent)
 {
-    WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTargetTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedChangedTouches;
-    WillBeHeapVector<RawPtrWillBeMember<TreeScope> > treeScopes;
+    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedTouches;
+    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedTargetTouches;
+    WillBeHeapVector<RawPtrWillBeMember<TouchList>> adjustedChangedTouches;
+    WillBeHeapVector<RawPtrWillBeMember<TreeScope>> treeScopes;
 
-    for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
-        TouchEventContext* touchEventContext = m_treeScopeEventContexts[i]->ensureTouchEventContext();
+    for (const auto& treeScopeEventContext : m_treeScopeEventContexts) {
+        TouchEventContext* touchEventContext = treeScopeEventContext->ensureTouchEventContext();
         adjustedTouches.append(&touchEventContext->touches());
         adjustedTargetTouches.append(&touchEventContext->targetTouches());
         adjustedChangedTouches.append(&touchEventContext->changedTouches());
-        treeScopes.append(&m_treeScopeEventContexts[i]->treeScope());
+        treeScopes.append(&treeScopeEventContext->treeScope());
     }
 
     adjustTouchList(node, touchEvent.touches(), adjustedTouches, treeScopes);
     adjustTouchList(node, touchEvent.targetTouches(), adjustedTargetTouches, treeScopes);
     adjustTouchList(node, touchEvent.changedTouches(), adjustedChangedTouches, treeScopes);
 
 #if ENABLE(ASSERT)
-    for (size_t i = 0; i < m_treeScopeEventContexts.size(); ++i) {
-        TreeScope& treeScope = m_treeScopeEventContexts[i]->treeScope();
-        TouchEventContext* touchEventContext = m_treeScopeEventContexts[i]->touchEventContext();
+    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 Node* node, const TouchList* touchList, WillBeHeapVector<RawPtrWillBeMember<TouchList> > adjustedTouchList, const WillBeHeapVector<RawPtrWillBeMember<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)));
         }
@@ skipping 10 matching lines @@
 
 void EventPath::trace(Visitor* visitor)
 {
     visitor->trace(m_nodeEventContexts);
     visitor->trace(m_node);
     visitor->trace(m_event);
     visitor->trace(m_treeScopeEventContexts);
 }
 
 } // namespace