ImageResource: remove unnecessary vector copying during iteration.

third_party/WebKit/Source/core/fetch/ImageResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 138 matching lines @@
 void ImageResource::checkNotify() {
   // Don't notify clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
   Resource::checkNotify();
 }
 
 void ImageResource::markObserverFinished(ImageResourceObserver* observer) {
-  if (m_observers.contains(observer)) {
-    m_finishedObservers.add(observer);
-    m_observers.remove(observer);
-  }
+  auto it = m_observers.find(observer);
+  if (it == m_observers.end())
+    return;
+  m_observers.remove(it);
+  m_finishedObservers.add(observer);
 }
 
 void ImageResource::didAddClient(ResourceClient* client) {
   DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
 
   // Don't notify observers and clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
@@ skipping 25 matching lines @@
   if (isLoaded() && m_observers.contains(observer) && !m_isSchedulingReload &&
       !shouldReloadBrokenPlaceholder()) {
     markObserverFinished(observer);
     observer->imageNotifyFinished(this);
   }
 }
 
 void ImageResource::removeObserver(ImageResourceObserver* observer) {
   DCHECK(observer);
 
-  if (m_observers.contains(observer))
-    m_observers.remove(observer);
-  else if (m_finishedObservers.contains(observer))
-    m_finishedObservers.remove(observer);
-  else
-    NOTREACHED();
-
+  auto it = m_observers.find(observer);
+  if (it != m_observers.end()) {
+    m_observers.remove(it);
+  } else {
+    it = m_finishedObservers.find(observer);
+    DCHECK(it != m_finishedObservers.end());
+    m_finishedObservers.remove(it);
+  }
   didRemoveClientOrObserver();
 }
 
 static void priorityFromObserver(const ImageResourceObserver* observer,
                                  ResourcePriority& priority) {
   ResourcePriority nextPriority = observer->computeResourcePriority();
   if (nextPriority.visibility == ResourcePriority::NotVisible)
     return;
   priority.visibility = ResourcePriority::Visible;
   priority.intraPriorityValue += nextPriority.intraPriorityValue;
 }
 
 ResourcePriority ImageResource::priorityFromObservers() {
   ResourcePriority priority;
 
-  for (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer))
-      priorityFromObserver(observer, priority);
-  }
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer))
-      priorityFromObserver(observer, priority);
-  }
+  for (const auto& it : m_finishedObservers)
+    priorityFromObserver(it.key, priority);
+  for (const auto& it : m_observers)
+    priorityFromObserver(it.key, priority);
 
   return priority;
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation() {
   clearImage();
   setDecodedSize(0);
 }
 
 void ImageResource::destroyDecodedDataIfPossible() {
@@ skipping 324 matching lines @@
   if (!image || image != m_image)
     return;
 
   setDecodedSize(newSize);
 }
 
 bool ImageResource::shouldPauseAnimation(const blink::Image* image) {
   if (!image || image != m_image)
     return false;
 
-  for (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer) && observer->willRenderImage())
+  for (const auto& it : m_finishedObservers)
+    if (it.key->willRenderImage())
       return false;
-  }
 
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer) && observer->willRenderImage())
+  for (const auto& it : m_observers)
+    if (it.key->willRenderImage())
       return false;
-  }
 
   return true;
 }
 
 void ImageResource::animationAdvanced(const blink::Image* image) {
   if (!image || image != m_image)
     return;
   notifyObservers(DoNotNotifyFinish);
 }
 
 void ImageResource::updateImageAnimationPolicy() {
   if (!m_image)
     return;
 
   ImageAnimationPolicy newPolicy = ImageAnimationPolicyAllowed;
-  for (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer) &&
-        observer->getImageAnimationPolicy(newPolicy))
+  for (const auto& it : m_finishedObservers) {
+    if (it.key->getImageAnimationPolicy(newPolicy))
       break;
   }
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer) &&
-        observer->getImageAnimationPolicy(newPolicy))
+  for (const auto& it : m_observers) {
+    if (it.key->getImageAnimationPolicy(newPolicy))
       break;
   }
 
   if (m_image->animationPolicy() != newPolicy) {
     m_image->resetAnimation();
     m_image->setAnimationPolicy(newPolicy);
   }
 }
 
 static bool isLoFiImage(const ImageResource& resource) {
@@ skipping 89 matching lines @@
            WebServiceWorkerResponseTypeOpaque;
   }
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink