Avoid WTF::Vector::at() and operator[] in core/dom.

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  *
@@ skipping 1796 matching lines @@
 ExecutionContext* Node::getExecutionContext() const {
   return document().contextDocument();
 }
 
 void Node::didMoveToNewDocument(Document& oldDocument) {
   TreeScopeAdopter::ensureDidMoveToNewDocumentWasCalled(oldDocument);
 
   if (const EventTargetData* eventTargetData = this->eventTargetData()) {
     const EventListenerMap& listenerMap = eventTargetData->eventListenerMap;
     if (!listenerMap.isEmpty()) {
-      Vector<AtomicString> types = listenerMap.eventTypes();
-      for (unsigned i = 0; i < types.size(); ++i)
-        document().addListenerTypeIfNeeded(types[i]);
+      for (const auto& type : listenerMap.eventTypes())
+        document().addListenerTypeIfNeeded(type);
     }
   }
 
   oldDocument.markers().removeMarkers(this);
   if (oldDocument.frameHost() && !document().frameHost())
     oldDocument.frameHost()->eventHandlerRegistry().didMoveOutOfFrameHost(
         *this);
   else if (document().frameHost() && !oldDocument.frameHost())
     document().frameHost()->eventHandlerRegistry().didMoveIntoFrameHost(*this);
   else if (oldDocument.frameHost() != document().frameHost())
     EventHandlerRegistry::didMoveBetweenFrameHosts(
         *this, oldDocument.frameHost(), document().frameHost());
 
   if (const HeapVector<TraceWrapperMember<MutationObserverRegistration>>*
           registry = mutationObserverRegistry()) {
-    for (size_t i = 0; i < registry->size(); ++i) {
-      document().addMutationObserverTypes(registry->at(i)->mutationTypes());
+    for (const auto& registration : *registry) {
+      document().addMutationObserverTypes(registration->mutationTypes());
     }
   }
 
   if (transientMutationObserverRegistry()) {
     for (MutationObserverRegistration* registration :
          *transientMutationObserverRegistry())
       document().addMutationObserverTypes(registration->mutationTypes());
   }
 }
 
@@ skipping 121 matching lines @@
         observers, node->transientMutationObserverRegistry(), *this, type,
         attributeName);
   }
 }
 
 void Node::registerMutationObserver(
     MutationObserver& observer,
     MutationObserverOptions options,
     const HashSet<AtomicString>& attributeFilter) {
   MutationObserverRegistration* registration = nullptr;
-  const HeapVector<TraceWrapperMember<MutationObserverRegistration>>& registry =
-      ensureRareData().ensureMutationObserverData().registry();
-  for (size_t i = 0; i < registry.size(); ++i) {
-    if (&registry[i]->observer() == &observer) {
-      registration = registry[i].get();
+  for (const auto& item :
+       ensureRareData().ensureMutationObserverData().registry()) {
+    if (&item->observer() == &observer) {
+      registration = item.get();
       registration->resetObservation(options, attributeFilter);
     }
   }
 
   if (!registration) {
     registration = MutationObserverRegistration::create(observer, this, options,
                                                         attributeFilter);
     ensureRareData().ensureMutationObserverData().addRegistration(registration);
   }
 
@@ skipping 35 matching lines @@
 }
 
 void Node::notifyMutationObserversNodeWillDetach() {
   if (!document().hasMutationObservers())
     return;
 
   ScriptForbiddenScope forbidScriptDuringRawIteration;
   for (Node* node = parentNode(); node; node = node->parentNode()) {
     if (const HeapVector<TraceWrapperMember<MutationObserverRegistration>>*
             registry = node->mutationObserverRegistry()) {
-      const size_t size = registry->size();
-      for (size_t i = 0; i < size; ++i)
-        registry->at(i)->observedSubtreeNodeWillDetach(*this);
+      for (const auto& registration : *registry)
+        registration->observedSubtreeNodeWillDetach(*this);
     }
 
     if (const HeapHashSet<TraceWrapperMember<MutationObserverRegistration>>*
             transientRegistry = node->transientMutationObserverRegistry()) {
       for (auto& registration : *transientRegistry)
         registration->observedSubtreeNodeWillDetach(*this);
     }
   }
 }
 
@@ skipping 235 matching lines @@
 
 void Node::decrementConnectedSubframeCount() {
   rareData()->decrementConnectedSubframeCount();
 }
 
 StaticNodeList* Node::getDestinationInsertionPoints() {
   updateDistribution();
   HeapVector<Member<InsertionPoint>, 8> insertionPoints;
   collectDestinationInsertionPoints(*this, insertionPoints);
   HeapVector<Member<Node>> filteredInsertionPoints;
-  for (size_t i = 0; i < insertionPoints.size(); ++i) {
-    InsertionPoint* insertionPoint = insertionPoints[i];
+  for (const auto& insertionPoint : insertionPoints) {
     DCHECK(insertionPoint->containingShadowRoot());
     if (!insertionPoint->containingShadowRoot()->isOpenOrV0())
       break;
     filteredInsertionPoints.append(insertionPoint);
   }
   return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 HTMLSlotElement* Node::assignedSlot() const {
   DCHECK(!isPseudoElement());
@@ skipping 237 matching lines @@
   if (node) {
     std::stringstream stream;
     node->printNodePathTo(stream);
     LOG(INFO) << stream.str();
   } else {
     LOG(INFO) << "Cannot showNodePath for <null>";
   }
 }
 
 #endif