https://bugs.webkit.org/show_bug.cgi?id=150664
Reviewed by Darin Adler.
No new tests because there is no behavior change.
* dom/AuthorStyleSheets.cpp:
(WebCore::AuthorStyleSheets::analyzeStyleSheetChange):
(WebCore::filterEnabledNonemptyCSSStyleSheets):
(WebCore::AuthorStyleSheets::activeStyleSheetsContains):
* dom/CheckedRadioButtons.cpp:
(WebCore::RadioButtonGroup::updateValidityForAllButtons):
* dom/ClientRectList.cpp:
(WebCore::ClientRectList::ClientRectList):
(WebCore::ClientRectList::~ClientRectList):
* dom/ContainerNode.cpp:
(WebCore::ContainerNode::insertBefore):
* dom/DOMNamedFlowCollection.cpp:
(WebCore::DOMNamedFlowCollection::DOMNamedFlowCollection):
(WebCore::DOMNamedFlowCollection::length):
(WebCore::DOMNamedFlowCollection::item):
(WebCore::DOMNamedFlowCollection::namedItem):
* dom/DOMStringList.cpp:
(WebCore::DOMStringList::contains):
* dom/Document.cpp:
(WebCore::Document::Document):
(WebCore::Document::~Document):
(WebCore::Document::removedLastRef):
(WebCore::Document::adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale):
(WebCore::Document::updateHoverActiveState):
* dom/DocumentMarkerController.cpp:
(WebCore::DocumentMarkerController::copyMarkers):
(WebCore::DocumentMarkerController::removeMarkers):
(WebCore::DocumentMarkerController::repaintMarkers):
(DocumentMarkerController::showMarkers):
* dom/ElementData.cpp:
(WebCore::UniqueElementData::findAttributeByName):
* dom/EventDispatcher.cpp:
(WebCore::EventPath::updateTouchLists):
(WebCore::EventPath::hasEventListeners):
* dom/EventListenerMap.cpp:
(WebCore::EventListenerMap::contains):
(WebCore::EventListenerMap::containsCapturing):
(WebCore::EventListenerMap::eventTypes):
(WebCore::EventListenerMap::add):
(WebCore::EventListenerMap::find):
(WebCore::copyListenersNotCreatedFromMarkupToTarget):
(WebCore::EventListenerMap::copyEventListenersNotCreatedFromMarkupToTarget):
(WebCore::EventListenerIterator::EventListenerIterator):
* dom/EventTarget.cpp:
(WebCore::EventTarget::removeEventListener):
(WebCore::EventTarget::getAttributeEventListener):
(WebCore::EventTarget::removeAllEventListeners):
* dom/IdTargetObserverRegistry.cpp:
(WebCore::IdTargetObserverRegistry::notifyObserversInternal):
* dom/MessagePort.cpp:
(WebCore::MessagePort::postMessage):
(WebCore::MessagePort::disentanglePorts):
* dom/MutationObserver.cpp:
(WebCore::MutationObserver::observe):
(WebCore::MutationObserver::deliver):
(WebCore::MutationObserver::deliverAllMutations):
* dom/NamedFlowCollection.cpp:
(WebCore::NamedFlowCollection::namedFlows):
(WebCore::NamedFlowCollection::createCSSOMSnapshot):
* dom/Node.cpp:
(WebCore::Node::notifyMutationObserversNodeWillDetach):
* dom/Range.cpp:
(WebCore::Range::processNodes):
(WebCore::Range::processAncestorsAndTheirSiblings):
(WebCore::Range::absoluteBoundingBox):
(WebCore::Range::collectSelectionRects):
* dom/ScriptRunner.cpp:
(WebCore::ScriptRunner::timerFired):
* dom/ScriptedAnimationController.cpp:
(WebCore::ScriptedAnimationController::serviceScriptedAnimations):
* dom/SelectorQuery.cpp:
(WebCore::SelectorDataList::matches):
(WebCore::SelectorDataList::executeFastPathForIdSelector):
(WebCore::SelectorDataList::executeSingleMultiSelectorData):
(WebCore::SelectorDataList::executeCompiledSingleMultiSelectorData):
(WebCore::SelectorDataList::execute):
* dom/TreeScopeAdopter.cpp:
(WebCore::TreeScopeAdopter::moveTreeToNewScope):
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@191792
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2015-10-30 Hunseop Jeong <hs85.jeong@samsung.com>
+
+ Use modern for-loops in WebCore/dom.
+ https://bugs.webkit.org/show_bug.cgi?id=150664
+
+ Reviewed by Darin Adler.
+
+ No new tests because there is no behavior change.
+
+ * dom/AuthorStyleSheets.cpp:
+ (WebCore::AuthorStyleSheets::analyzeStyleSheetChange):
+ (WebCore::filterEnabledNonemptyCSSStyleSheets):
+ (WebCore::AuthorStyleSheets::activeStyleSheetsContains):
+ * dom/CheckedRadioButtons.cpp:
+ (WebCore::RadioButtonGroup::updateValidityForAllButtons):
+ * dom/ClientRectList.cpp:
+ (WebCore::ClientRectList::ClientRectList):
+ (WebCore::ClientRectList::~ClientRectList):
+ * dom/ContainerNode.cpp:
+ (WebCore::ContainerNode::insertBefore):
+ * dom/DOMNamedFlowCollection.cpp:
+ (WebCore::DOMNamedFlowCollection::DOMNamedFlowCollection):
+ (WebCore::DOMNamedFlowCollection::length):
+ (WebCore::DOMNamedFlowCollection::item):
+ (WebCore::DOMNamedFlowCollection::namedItem):
+ * dom/DOMStringList.cpp:
+ (WebCore::DOMStringList::contains):
+ * dom/Document.cpp:
+ (WebCore::Document::Document):
+ (WebCore::Document::~Document):
+ (WebCore::Document::removedLastRef):
+ (WebCore::Document::adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale):
+ (WebCore::Document::updateHoverActiveState):
+ * dom/DocumentMarkerController.cpp:
+ (WebCore::DocumentMarkerController::copyMarkers):
+ (WebCore::DocumentMarkerController::removeMarkers):
+ (WebCore::DocumentMarkerController::repaintMarkers):
+ (DocumentMarkerController::showMarkers):
+ * dom/ElementData.cpp:
+ (WebCore::UniqueElementData::findAttributeByName):
+ * dom/EventDispatcher.cpp:
+ (WebCore::EventPath::updateTouchLists):
+ (WebCore::EventPath::hasEventListeners):
+ * dom/EventListenerMap.cpp:
+ (WebCore::EventListenerMap::contains):
+ (WebCore::EventListenerMap::containsCapturing):
+ (WebCore::EventListenerMap::eventTypes):
+ (WebCore::EventListenerMap::add):
+ (WebCore::EventListenerMap::find):
+ (WebCore::copyListenersNotCreatedFromMarkupToTarget):
+ (WebCore::EventListenerMap::copyEventListenersNotCreatedFromMarkupToTarget):
+ (WebCore::EventListenerIterator::EventListenerIterator):
+ * dom/EventTarget.cpp:
+ (WebCore::EventTarget::removeEventListener):
+ (WebCore::EventTarget::getAttributeEventListener):
+ (WebCore::EventTarget::removeAllEventListeners):
+ * dom/IdTargetObserverRegistry.cpp:
+ (WebCore::IdTargetObserverRegistry::notifyObserversInternal):
+ * dom/MessagePort.cpp:
+ (WebCore::MessagePort::postMessage):
+ (WebCore::MessagePort::disentanglePorts):
+ * dom/MutationObserver.cpp:
+ (WebCore::MutationObserver::observe):
+ (WebCore::MutationObserver::deliver):
+ (WebCore::MutationObserver::deliverAllMutations):
+ * dom/NamedFlowCollection.cpp:
+ (WebCore::NamedFlowCollection::namedFlows):
+ (WebCore::NamedFlowCollection::createCSSOMSnapshot):
+ * dom/Node.cpp:
+ (WebCore::Node::notifyMutationObserversNodeWillDetach):
+ * dom/Range.cpp:
+ (WebCore::Range::processNodes):
+ (WebCore::Range::processAncestorsAndTheirSiblings):
+ (WebCore::Range::absoluteBoundingBox):
+ (WebCore::Range::collectSelectionRects):
+ * dom/ScriptRunner.cpp:
+ (WebCore::ScriptRunner::timerFired):
+ * dom/ScriptedAnimationController.cpp:
+ (WebCore::ScriptedAnimationController::serviceScriptedAnimations):
+ * dom/SelectorQuery.cpp:
+ (WebCore::SelectorDataList::matches):
+ (WebCore::SelectorDataList::executeFastPathForIdSelector):
+ (WebCore::SelectorDataList::executeSingleMultiSelectorData):
+ (WebCore::SelectorDataList::executeCompiledSingleMultiSelectorData):
+ (WebCore::SelectorDataList::execute):
+ * dom/TreeScopeAdopter.cpp:
+ (WebCore::TreeScopeAdopter::moveTreeToNewScope):
+
2015-10-30 Carlos Garcia Campos <cgarcia@igalia.com>
Make every port implement MainThreadSharedTimer instead of using global functions
// Stylesheets of <style> elements that @import stylesheets are active but loading. We need to trigger a full recalc when such loads are done.
bool hasActiveLoadingStylesheet = false;
unsigned newStylesheetCount = newStylesheets.size();
- for (unsigned i = 0; i < newStylesheetCount; ++i) {
- if (newStylesheets[i]->isLoading())
+ for (auto& sheet : newStylesheets) {
+ if (sheet->isLoading())
hasActiveLoadingStylesheet = true;
}
if (m_hadActiveLoadingStylesheet && !hasActiveLoadingStylesheet) {
static void filterEnabledNonemptyCSSStyleSheets(Vector<RefPtr<CSSStyleSheet>>& result, const Vector<RefPtr<StyleSheet>>& sheets)
{
- for (unsigned i = 0; i < sheets.size(); ++i) {
- if (!is<CSSStyleSheet>(*sheets[i]))
+ for (auto& sheet : sheets) {
+ if (!is<CSSStyleSheet>(*sheet))
continue;
- CSSStyleSheet& sheet = downcast<CSSStyleSheet>(*sheets[i]);
- if (sheet.disabled())
+ CSSStyleSheet& styleSheet = downcast<CSSStyleSheet>(*sheet);
+ if (styleSheet.disabled())
continue;
- if (!sheet.length())
+ if (!styleSheet.length())
continue;
- result.append(&sheet);
+ result.append(&styleSheet);
}
}
{
if (!m_weakCopyOfActiveStyleSheetListForFastLookup) {
m_weakCopyOfActiveStyleSheetListForFastLookup = std::make_unique<HashSet<const CSSStyleSheet*>>();
- for (unsigned i = 0; i < m_activeStyleSheets.size(); ++i)
- m_weakCopyOfActiveStyleSheetListForFastLookup->add(m_activeStyleSheets[i].get());
+ for (auto& activeStyleSheet : m_activeStyleSheets)
+ m_weakCopyOfActiveStyleSheetListForFastLookup->add(activeStyleSheet.get());
}
return m_weakCopyOfActiveStyleSheetListForFastLookup->contains(sheet);
}
void RadioButtonGroup::updateValidityForAllButtons()
{
- typedef HashSet<HTMLInputElement*>::const_iterator Iterator;
- Iterator end = m_members.end();
- for (Iterator it = m_members.begin(); it != end; ++it) {
- HTMLInputElement* button = *it;
+ for (auto& button : m_members) {
ASSERT(button->isRadioButton());
button->updateValidity();
}
ClientRectList::ClientRectList(const Vector<FloatQuad>& quads)
{
m_list.reserveInitialCapacity(quads.size());
- for (size_t i = 0; i < quads.size(); ++i)
- m_list.append(ClientRect::create(quads[i].enclosingBoundingBox()));
+ for (auto& quad : quads)
+ m_list.uncheckedAppend(ClientRect::create(quad.enclosingBoundingBox()));
}
ClientRectList::~ClientRectList()
InspectorInstrumentation::willInsertDOMNode(document(), *this);
ChildListMutationScope mutation(*this);
- for (auto it = targets.begin(), end = targets.end(); it != end; ++it) {
- Node& child = it->get();
-
+ for (auto& child : targets) {
// Due to arbitrary code running in response to a DOM mutation event it's
// possible that "next" is no longer a child of "this".
// It's also possible that "child" has been inserted elsewhere.
// In either of those cases, we'll just stop.
if (next->parentNode() != this)
break;
- if (child.parentNode())
+ if (child->parentNode())
break;
- treeScope().adoptIfNeeded(&child);
+ treeScope().adoptIfNeeded(child.ptr());
insertBeforeCommon(next, child);
DOMNamedFlowCollection::DOMNamedFlowCollection(const Vector<WebKitNamedFlow*>& namedFlows)
{
- for (Vector<WebKitNamedFlow*>::const_iterator it = namedFlows.begin(); it != namedFlows.end(); ++it)
- m_namedFlows.add(*it);
+ for (auto& flow : namedFlows)
+ m_namedFlows.add(flow);
}
unsigned long DOMNamedFlowCollection::length() const
{
if (index >= static_cast<unsigned long>(m_namedFlows.size()))
return nullptr;
- DOMNamedFlowSet::const_iterator it = m_namedFlows.begin();
+ auto it = m_namedFlows.begin();
for (unsigned long i = 0; i < index; ++i)
++it;
return *it;
RefPtr<WebKitNamedFlow> DOMNamedFlowCollection::namedItem(const AtomicString& name) const
{
- DOMNamedFlowSet::const_iterator it = m_namedFlows.find<String, DOMNamedFlowHashTranslator>(name);
+ auto it = m_namedFlows.find<String, DOMNamedFlowHashTranslator>(name);
if (it != m_namedFlows.end())
return *it;
return nullptr;
// FIXME: Currently, all consumers of DOMStringList store fairly small lists and thus an O(n)
// algorithm is OK. But this may need to be optimized if larger amounts of data are
// stored in m_strings.
- size_t count = m_strings.size();
- for (size_t i = 0; i < count; ++i) {
- if (m_strings[i] == string)
+ for (auto& value : m_strings) {
+ if (value == string)
return true;
}
return false;
initSecurityContext();
initDNSPrefetch();
- for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListAndCollectionCounts); ++i)
- m_nodeListAndCollectionCounts[i] = 0;
+ for (auto& nodeListAndCollectionCount : m_nodeListAndCollectionCounts)
+ nodeListAndCollectionCount = 0;
}
#if ENABLE(FULLSCREEN_API)
inverseFrameScale = 1 / frame()->frameScaleFactor();
LayoutRect visibleContentRect = view()->visibleContentRect();
- for (size_t i = 0; i < quads.size(); ++i) {
- quads[i].move(-visibleContentRect.x(), -visibleContentRect.y());
+ for (auto& quad : quads) {
+ quad.move(-visibleContentRect.x(), -visibleContentRect.y());
if (zoom != 1)
- quads[i].scale(1 / zoom, 1 / zoom);
+ quad.scale(1 / zoom, 1 / zoom);
if (inverseFrameScale != 1)
- quads[i].scale(inverseFrameScale, inverseFrameScale);
+ quad.scale(inverseFrameScale, inverseFrameScale);
}
}
elementsToAddToChain.append(element);
}
- size_t removeCount = elementsToRemoveFromChain.size();
- for (size_t i = 0; i < removeCount; ++i)
- elementsToRemoveFromChain[i]->setHovered(false);
+ for (auto& element : elementsToRemoveFromChain)
+ element->setHovered(false);
bool sawCommonAncestor = false;
- for (size_t i = 0, size = elementsToAddToChain.size(); i < size; ++i) {
+ for (auto& element : elementsToAddToChain) {
if (allowActiveChanges)
- elementsToAddToChain[i]->setActive(true);
- if (ancestor && elementsToAddToChain[i] == ancestor->element())
+ element->setActive(true);
+ if (ancestor && element == ancestor->element())
sawCommonAncestor = true;
if (!sawCommonAncestor) {
// Elements after the common hover ancestor does not change hover state, but are iterated over because they may change active state.
- elementsToAddToChain[i]->setHovered(true);
+ element->setHovered(true);
}
}
bool docDirty = false;
unsigned endOffset = startOffset + length - 1;
- for (size_t i = 0; i != list->size(); ++i) {
- DocumentMarker marker = list->at(i);
-
+ for (auto& marker : *list) {
// stop if we are now past the specified range
if (marker.startOffset() > endOffset)
break;
Vector<RefPtr<Node>> nodesWithMarkers;
copyKeysToVector(m_markers, nodesWithMarkers);
- unsigned size = nodesWithMarkers.size();
- for (unsigned i = 0; i < size; ++i) {
- MarkerMap::iterator iterator = m_markers.find(nodesWithMarkers[i]);
+ for (auto& node : nodesWithMarkers) {
+ auto iterator = m_markers.find(node);
if (iterator != m_markers.end())
removeMarkersFromList(iterator, markerTypes);
}
ASSERT(!m_markers.isEmpty());
// outer loop: process each markered node in the document
- MarkerMap::iterator end = m_markers.end();
- for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
- Node* node = i->key.get();
+ for (auto& marker : m_markers) {
+ Node* node = marker.key.get();
// inner loop: process each marker in the current node
- MarkerList* list = i->value.get();
bool nodeNeedsRepaint = false;
- for (auto& marker : *list) {
- if (markerTypes.contains(marker.type())) {
+ for (auto& documentMarker : *marker.value) {
+ if (markerTypes.contains(documentMarker.type())) {
nodeNeedsRepaint = true;
break;
}
void DocumentMarkerController::showMarkers() const
{
fprintf(stderr, "%d nodes have markers:\n", m_markers.size());
- MarkerMap::const_iterator end = m_markers.end();
- for (MarkerMap::const_iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
- Node* node = nodeIterator->key.get();
+ for (auto& marker : m_markers) {
+ Node* node = marker.key.get();
fprintf(stderr, "%p", node);
- MarkerList* list = nodeIterator->value.get();
- for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex) {
- const DocumentMarker& marker = list->at(markerIndex);
- fprintf(stderr, " %d:[%d:%d](%d)", marker.type(), marker.startOffset(), marker.endOffset(), marker.activeMatch());
- }
+ for (auto& documentMarker : *marker.value)
+ fprintf(stderr, " %d:[%d:%d](%d)", documentMarker.type(), documentMarker.startOffset(), documentMarker.endOffset(), documentMarker.activeMatch());
fprintf(stderr, "\n");
}
Attribute* UniqueElementData::findAttributeByName(const QualifiedName& name)
{
- for (unsigned i = 0, count = m_attributeVector.size(); i < count; ++i) {
- if (m_attributeVector.at(i).name().matches(name))
- return &m_attributeVector.at(i);
+ for (auto& attribute : m_attributeVector) {
+ if (attribute.name().matches(name))
+ return &attribute;
}
return nullptr;
}
addRelatedNodeResolversForTouchList(touchTargetResolvers, touchEvent.changedTouches(), TouchEventContext::ChangedTouches);
ASSERT(touchTargetResolvers.size() == touchNodeCount);
- size_t eventPathSize = m_path.size();
- for (size_t i = 0; i < eventPathSize; ++i) {
- TouchEventContext& context = toTouchEventContext(*m_path[i]);
+ for (auto& eventPath : m_path) {
+ TouchEventContext& context = toTouchEventContext(*eventPath);
Node& nodeToMoveTo = *context.node();
for (size_t resolverIndex = 0; resolverIndex < touchNodeCount; ++resolverIndex) {
EventRelatedNodeResolver& currentResolver = touchTargetResolvers[resolverIndex];
bool EventPath::hasEventListeners(const AtomicString& eventType) const
{
- for (size_t i = 0; i < m_path.size(); i++) {
- if (m_path[i]->node()->hasEventListeners(eventType))
+ for (auto& eventPath : m_path) {
+ if (eventPath->node()->hasEventListeners(eventType))
return true;
}
bool EventListenerMap::contains(const AtomicString& eventType) const
{
- for (unsigned i = 0; i < m_entries.size(); ++i) {
- if (m_entries[i].first == eventType)
+ for (auto& entry : m_entries) {
+ if (entry.first == eventType)
return true;
}
return false;
bool EventListenerMap::containsCapturing(const AtomicString& eventType) const
{
- for (unsigned i = 0; i < m_entries.size(); ++i) {
- if (m_entries[i].first == eventType) {
- const EventListenerVector* vector = m_entries[i].second.get();
- for (unsigned j = 0; j < vector->size(); ++j) {
- if (vector->at(j).useCapture)
+ for (auto& entry : m_entries) {
+ if (entry.first == eventType) {
+ for (auto& eventListener : *entry.second) {
+ if (eventListener.useCapture)
return true;
}
}
Vector<AtomicString> types;
types.reserveInitialCapacity(m_entries.size());
- for (unsigned i = 0; i < m_entries.size(); ++i)
- types.uncheckedAppend(m_entries[i].first);
+ for (auto& entry : m_entries)
+ types.uncheckedAppend(entry.first);
return types;
}
{
assertNoActiveIterators();
- for (unsigned i = 0; i < m_entries.size(); ++i) {
- if (m_entries[i].first == eventType)
- return addListenerToVector(m_entries[i].second.get(), listener, useCapture);
+ for (auto& entry : m_entries) {
+ if (entry.first == eventType)
+ return addListenerToVector(entry.second.get(), listener, useCapture);
}
m_entries.append(std::make_pair(eventType, std::make_unique<EventListenerVector>()));
{
assertNoActiveIterators();
- for (unsigned i = 0; i < m_entries.size(); ++i) {
- if (m_entries[i].first == eventType)
- return m_entries[i].second.get();
+ for (auto& entry : m_entries) {
+ if (entry.first == eventType)
+ return entry.second.get();
}
return nullptr;
static void copyListenersNotCreatedFromMarkupToTarget(const AtomicString& eventType, EventListenerVector* listenerVector, EventTarget* target)
{
- for (size_t i = 0; i < listenerVector->size(); ++i) {
+ for (auto& listener : *listenerVector) {
// Event listeners created from markup have already been transfered to the shadow tree during cloning.
- if ((*listenerVector)[i].listener->wasCreatedFromMarkup())
+ if (listener.listener->wasCreatedFromMarkup())
continue;
- target->addEventListener(eventType, (*listenerVector)[i].listener.copyRef(), (*listenerVector)[i].useCapture);
+ target->addEventListener(eventType, listener.listener.copyRef(), listener.useCapture);
}
}
{
assertNoActiveIterators();
- for (unsigned i = 0; i < m_entries.size(); ++i)
- copyListenersNotCreatedFromMarkupToTarget(m_entries[i].first, m_entries[i].second.get(), target);
+ for (auto& entry : m_entries)
+ copyListenersNotCreatedFromMarkupToTarget(entry.first, entry.second.get(), target);
}
EventListenerIterator::EventListenerIterator()
// they have one less listener to invoke.
if (!d->firingEventIterators)
return true;
- for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
- FiringEventIterator& firingIterator = d->firingEventIterators->at(i);
+ for (auto& firingIterator : *d->firingEventIterators) {
if (eventType != firingIterator.eventType)
continue;
EventListener* EventTarget::getAttributeEventListener(const AtomicString& eventType)
{
- const EventListenerVector& entry = getEventListeners(eventType);
- for (size_t i = 0; i < entry.size(); ++i) {
- if (entry[i].listener->isAttribute())
- return entry[i].listener.get();
+ for (auto& eventListener : getEventListeners(eventType)) {
+ if (eventListener.listener->isAttribute())
+ return eventListener.listener.get();
}
return 0;
}
// Notify firing events planning to invoke the listener at 'index' that
// they have one less listener to invoke.
if (d->firingEventIterators) {
- for (size_t i = 0; i < d->firingEventIterators->size(); ++i) {
- d->firingEventIterators->at(i).iterator = 0;
- d->firingEventIterators->at(i).size = 0;
+ for (auto& firingEventIterator : *d->firingEventIterators) {
+ firingEventIterator.iterator = 0;
+ firingEventIterator.size = 0;
}
}
}
Vector<IdTargetObserver*> copy;
copyToVector(*m_notifyingObserversInSet, copy);
- for (Vector<IdTargetObserver*>::const_iterator it = copy.begin(); it != copy.end(); ++it) {
- if (m_notifyingObserversInSet->contains(*it))
- (*it)->idTargetChanged();
+ for (auto& observer : copy) {
+ if (m_notifyingObserversInSet->contains(observer))
+ observer->idTargetChanged();
}
if (m_notifyingObserversInSet->isEmpty())
m_registry.remove(&id);
- m_notifyingObserversInSet = 0;
+ m_notifyingObserversInSet = nullptr;
}
} // namespace WebCore
std::unique_ptr<MessagePortChannelArray> channels;
// Make sure we aren't connected to any of the passed-in ports.
if (ports) {
- for (unsigned int i = 0; i < ports->size(); ++i) {
- MessagePort* dataPort = (*ports)[i].get();
- if (dataPort == this || m_entangledChannel->isConnectedTo(dataPort)) {
+ for (auto& dataPort : *ports) {
+ if (dataPort == this || m_entangledChannel->isConnectedTo(dataPort.get())) {
ec = DATA_CLONE_ERR;
return;
}
HashSet<MessagePort*> portSet;
// Walk the incoming array - if there are any duplicate ports, or null ports or cloned ports, throw an error (per section 8.3.3 of the HTML5 spec).
- for (unsigned int i = 0; i < ports->size(); ++i) {
- MessagePort* port = (*ports)[i].get();
- if (!port || port->isNeutered() || portSet.contains(port)) {
+ for (auto& port : *ports) {
+ if (!port || port->isNeutered() || portSet.contains(port.get())) {
ec = DATA_CLONE_ERR;
return nullptr;
}
- portSet.add(port);
+ portSet.add(port.get());
}
// Passed-in ports passed validity checks, so we can disentangle them.
};
MutationObserverOptions options = 0;
bool value = false;
- for (unsigned i = 0; i < sizeof(booleanOptions) / sizeof(booleanOptions[0]); ++i) {
- if (optionsDictionary.get(booleanOptions[i].name, value) && value)
- options |= booleanOptions[i].value;
+ for (auto& booleanOption : booleanOptions) {
+ if (optionsDictionary.get(booleanOption.name, value) && value)
+ options |= booleanOption.value;
}
HashSet<AtomicString> attributeFilter;
if (registration->hasTransientRegistrations())
transientRegistrations.append(registration);
}
- for (size_t i = 0; i < transientRegistrations.size(); ++i)
- transientRegistrations[i]->clearTransientRegistrations();
+ for (auto& registration : transientRegistrations)
+ registration->clearTransientRegistrations();
if (m_records.isEmpty())
return;
if (!suspendedMutationObservers().isEmpty()) {
Vector<RefPtr<MutationObserver>> suspended;
copyToVector(suspendedMutationObservers(), suspended);
- for (size_t i = 0; i < suspended.size(); ++i) {
- if (!suspended[i]->canDeliver())
+ for (auto& observer : suspended) {
+ if (!observer->canDeliver())
continue;
- suspendedMutationObservers().remove(suspended[i]);
- activeMutationObservers().add(suspended[i]);
+ suspendedMutationObservers().remove(observer);
+ activeMutationObservers().add(observer);
}
}
return lhs->m_priority < rhs->m_priority;
});
- for (size_t i = 0; i < observers.size(); ++i) {
- if (observers[i]->canDeliver())
- observers[i]->deliver();
+ for (auto& observer : observers) {
+ if (observer->canDeliver())
+ observer->deliver();
else
- suspendedMutationObservers().add(observers[i]);
+ suspendedMutationObservers().add(observer);
}
}
{
Vector<RefPtr<WebKitNamedFlow>> namedFlows;
- for (NamedFlowSet::iterator it = m_namedFlows.begin(); it != m_namedFlows.end(); ++it) {
- if ((*it)->flowState() == WebKitNamedFlow::FlowStateNull)
+ for (auto& namedFlow : m_namedFlows) {
+ if (namedFlow->flowState() == WebKitNamedFlow::FlowStateNull)
continue;
- namedFlows.append(RefPtr<WebKitNamedFlow>(*it));
+ namedFlows.append(RefPtr<WebKitNamedFlow>(namedFlow));
}
return namedFlows;
PassRefPtr<DOMNamedFlowCollection> NamedFlowCollection::createCSSOMSnapshot()
{
Vector<WebKitNamedFlow*> createdFlows;
- for (NamedFlowSet::iterator it = m_namedFlows.begin(); it != m_namedFlows.end(); ++it)
- if ((*it)->flowState() == WebKitNamedFlow::FlowStateCreated)
- createdFlows.append(*it);
+ for (auto& namedFlow : m_namedFlows) {
+ if (namedFlow->flowState() == WebKitNamedFlow::FlowStateCreated)
+ createdFlows.append(namedFlow);
+ }
return DOMNamedFlowCollection::create(createdFlows);
}
for (Node* node = parentNode(); node; node = node->parentNode()) {
if (auto* registry = node->mutationObserverRegistry()) {
- const size_t size = registry->size();
- for (size_t i = 0; i < size; ++i)
- registry->at(i)->observedSubtreeNodeWillDetach(this);
+ for (auto& registration : *registry)
+ registration->observedSubtreeNodeWillDetach(this);
}
if (auto* transientRegistry = node->transientMutationObserverRegistry()) {
void Range::processNodes(ActionType action, Vector<RefPtr<Node>>& nodes, PassRefPtr<Node> oldContainer, PassRefPtr<Node> newContainer, ExceptionCode& ec)
{
- for (unsigned i = 0; i < nodes.size(); i++) {
+ for (auto& node : nodes) {
switch (action) {
case Delete:
- oldContainer->removeChild(nodes[i].get(), ec);
+ oldContainer->removeChild(node.get(), ec);
break;
case Extract:
- newContainer->appendChild(nodes[i].release(), ec); // will remove n from its parent
+ newContainer->appendChild(node.release(), ec); // will remove n from its parent
break;
case Clone:
- newContainer->appendChild(nodes[i]->cloneNode(true), ec);
+ newContainer->appendChild(node->cloneNode(true), ec);
break;
}
}
ancestors.append(n);
RefPtr<Node> firstChildInAncestorToProcess = direction == ProcessContentsForward ? container->nextSibling() : container->previousSibling();
- for (Vector<RefPtr<Node>>::const_iterator it = ancestors.begin(); it != ancestors.end(); ++it) {
- RefPtr<Node> ancestor = *it;
+ for (auto& ancestor : ancestors) {
if (action == Extract || action == Clone) {
if (RefPtr<Node> clonedAncestor = ancestor->cloneNode(false)) { // Might have been removed already during mutation event.
clonedAncestor->appendChild(clonedContainer, ec);
child = (direction == ProcessContentsForward) ? child->nextSibling() : child->previousSibling())
nodes.append(child);
- for (NodeVector::const_iterator it = nodes.begin(); it != nodes.end(); ++it) {
- Node* child = it->get();
+ for (auto& child : nodes) {
switch (action) {
case Delete:
- ancestor->removeChild(child, ec);
+ ancestor->removeChild(child.get(), ec);
break;
case Extract: // will remove child from ancestor
if (direction == ProcessContentsForward)
- clonedContainer->appendChild(child, ec);
+ clonedContainer->appendChild(child.get(), ec);
else
- clonedContainer->insertBefore(child, clonedContainer->firstChild(), ec);
+ clonedContainer->insertBefore(child.get(), clonedContainer->firstChild(), ec);
break;
case Clone:
if (direction == ProcessContentsForward)
IntRect result;
Vector<IntRect> rects;
absoluteTextRects(rects);
- const size_t n = rects.size();
- for (size_t i = 0; i < n; ++i)
- result.unite(rects[i]);
+ for (auto& rect : rects)
+ result.unite(rect);
return result;
}
int beginSelectionOffset = isStartNode ? startOffset : 0;
int endSelectionOffset = isEndNode ? endOffset : std::numeric_limits<int>::max();
renderer->collectSelectionRects(newRects, beginSelectionOffset, endSelectionOffset);
- size_t numberOfNewRects = newRects.size();
- for (size_t i = 0; i < numberOfNewRects; ++i) {
- SelectionRect& selectionRect = newRects[i];
+ for (auto& selectionRect : newRects) {
if (selectionRect.containsStart() && !isStartNode)
selectionRect.setContainsStart(false);
if (selectionRect.containsEnd() && !isEndNode)
selectionRect.setContainsEnd(false);
if (selectionRect.logicalWidth() || selectionRect.logicalHeight())
- rects.append(newRects[i]);
+ rects.append(selectionRect);
}
newRects.shrink(0);
}
if (numInOrderScriptsToExecute)
m_scriptsToExecuteInOrder.remove(0, numInOrderScriptsToExecute);
- size_t size = scripts.size();
- for (size_t i = 0; i < size; ++i) {
- CachedScript* cachedScript = scripts[i].cachedScript();
- RefPtr<Element> element = scripts[i].releaseElementAndClear();
+ for (auto& script : scripts) {
+ CachedScript* cachedScript = script.cachedScript();
+ RefPtr<Element> element = script.releaseElementAndClear();
ASSERT(element);
// Paper over https://bugs.webkit.org/show_bug.cgi?id=144050
if (!element)
// reference to us, so take a defensive reference.
Ref<ScriptedAnimationController> protect(*this);
- for (size_t i = 0; i < callbacks.size(); ++i) {
- RequestAnimationFrameCallback* callback = callbacks[i].get();
+ for (auto& callback : callbacks) {
if (!callback->m_firedOrCancelled) {
callback->m_firedOrCancelled = true;
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireAnimationFrame(m_document, callback->m_id);
bool SelectorDataList::matches(Element& targetElement) const
{
- unsigned selectorCount = m_selectors.size();
- for (unsigned i = 0; i < selectorCount; ++i) {
- if (selectorMatches(m_selectors[i], targetElement, targetElement))
+ for (auto& selctor : m_selectors) {
+ if (selectorMatches(selctor, targetElement, targetElement))
return true;
}
return false;
if (UNLIKELY(rootNode.treeScope().containsMultipleElementsWithId(idToMatch))) {
const Vector<Element*>* elements = rootNode.treeScope().getAllElementsById(idToMatch);
ASSERT(elements);
- size_t count = elements->size();
bool rootNodeIsTreeScopeRoot = isTreeScopeRoot(rootNode);
- for (size_t i = 0; i < count; ++i) {
- Element& element = *elements->at(i);
- if ((rootNodeIsTreeScopeRoot || element.isDescendantOf(&rootNode)) && selectorMatches(selectorData, element, rootNode)) {
- SelectorQueryTrait::appendOutputForElement(output, &element);
+ for (auto& element : *elements) {
+ if ((rootNodeIsTreeScopeRoot || element->isDescendantOf(&rootNode)) && selectorMatches(selectorData, *element, rootNode)) {
+ SelectorQueryTrait::appendOutputForElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
template <typename SelectorQueryTrait>
ALWAYS_INLINE void SelectorDataList::executeSingleMultiSelectorData(const ContainerNode& rootNode, typename SelectorQueryTrait::OutputType& output) const
{
- unsigned selectorCount = m_selectors.size();
for (auto& element : elementDescendants(const_cast<ContainerNode&>(rootNode))) {
- for (unsigned i = 0; i < selectorCount; ++i) {
- if (selectorMatches(m_selectors[i], element, rootNode)) {
+ for (auto& selector : m_selectors) {
+ if (selectorMatches(selector, element, rootNode)) {
SelectorQueryTrait::appendOutputForElement(output, &element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
{
SelectorChecker::CheckingContext checkingContext(SelectorChecker::Mode::QueryingRules);
checkingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
- unsigned selectorCount = m_selectors.size();
for (auto& element : elementDescendants(const_cast<ContainerNode&>(rootNode))) {
- for (unsigned i = 0; i < selectorCount; ++i) {
+ for (auto& selector : m_selectors) {
#if CSS_SELECTOR_JIT_PROFILING
- m_selectors[i].compiledSelectorUsed();
+ selector.compiledSelectorUsed();
#endif
bool matched = false;
- void* compiledSelectorChecker = m_selectors[i].compiledSelectorCodeRef.code().executableAddress();
- if (m_selectors[i].compilationStatus == SelectorCompilationStatus::SimpleSelectorChecker) {
- SelectorCompiler::QuerySelectorSimpleSelectorChecker selectorChecker = SelectorCompiler::querySelectorSimpleSelectorCheckerFunction(compiledSelectorChecker, m_selectors[i].compilationStatus);
+ void* compiledSelectorChecker = selector.compiledSelectorCodeRef.code().executableAddress();
+ if (selector.compilationStatus == SelectorCompilationStatus::SimpleSelectorChecker) {
+ auto selectorChecker = SelectorCompiler::querySelectorSimpleSelectorCheckerFunction(compiledSelectorChecker, selector.compilationStatus);
matched = selectorChecker(&element);
} else {
- ASSERT(m_selectors[i].compilationStatus == SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
- SelectorCompiler::QuerySelectorSelectorCheckerWithCheckingContext selectorChecker = SelectorCompiler::querySelectorSelectorCheckerFunctionWithCheckingContext(compiledSelectorChecker, m_selectors[i].compilationStatus);
+ ASSERT(selector.compilationStatus == SelectorCompilationStatus::SelectorCheckerWithCheckingContext);
+ auto selectorChecker = SelectorCompiler::querySelectorSelectorCheckerFunctionWithCheckingContext(compiledSelectorChecker, selector.compilationStatus);
matched = selectorChecker(&element, &checkingContext);
}
if (matched) {
case CompilableMultipleSelectorMatch:
#if ENABLE(CSS_SELECTOR_JIT)
{
- unsigned selectorCount = m_selectors.size();
- for (unsigned i = 0; i < selectorCount; ++i) {
- if (!compileSelector(m_selectors[i], *searchRootNode)) {
+ for (auto& selector : m_selectors) {
+ if (!compileSelector(selector, *searchRootNode)) {
m_matchType = MultipleSelectorMatch;
goto MultipleSelectorMatch;
}
continue;
if (node->hasSyntheticAttrChildNodes()) {
- const Vector<RefPtr<Attr>>& attrs = downcast<Element>(*node).attrNodeList();
- for (unsigned i = 0; i < attrs.size(); ++i)
- moveTreeToNewScope(attrs[i].get());
+ for (auto& attr : downcast<Element>(*node).attrNodeList())
+ moveTreeToNewScope(attr.get());
}
if (ShadowRoot* shadow = node->shadowRoot()) {