Migrate WTF::HashCountedSet::remove() to ::erase()

third_party/WebKit/Source/platform/loader/fetch/Resource.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, 2008, 2009, 2010, 2011 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
@@ skipping 353 matching lines @@
   ResourceClientWalker<ResourceClient> w(m_clients);
   while (ResourceClient* c = w.next()) {
     markClientFinished(c);
     c->notifyFinished(this);
   }
 }
 
 void Resource::markClientFinished(ResourceClient* client) {
   if (m_clients.contains(client)) {
     m_finishedClients.insert(client);
-    m_clients.remove(client);
+    m_clients.erase(client);
   }
 }
 
 void Resource::appendData(const char* data, size_t length) {
   TRACE_EVENT0("blink", "Resource::appendData");
   DCHECK(!m_isRevalidating);
   DCHECK(!errorOccurred());
   if (m_options.dataBufferingPolicy == DoNotBufferData)
     return;
   if (m_data)
@@ skipping 268 matching lines @@
     builder.append("in_memory_cache");
   }
   return builder.toString();
 }
 
 void Resource::didAddClient(ResourceClient* c) {
   if (isLoaded()) {
     c->notifyFinished(this);
     if (m_clients.contains(c)) {
       m_finishedClients.insert(c);
-      m_clients.remove(c);
+      m_clients.erase(c);
     }
   }
 }
 
 static bool typeNeedsSynchronousCacheHit(Resource::Type type) {
   // Some resources types default to return data synchronously. For most of
   // these, it's because there are layout tests that expect data to return
   // synchronously in case of cache hit. In the case of fonts, there was a
   // performance regression.
   // FIXME: Get to the point where we don't need to special-case sync/async
@@ skipping 56 matching lines @@
   return;
 }
 
 void Resource::removeClient(ResourceClient* client) {
   CHECK(!m_isAddRemoveClientProhibited);
 
   // This code may be called in a pre-finalizer, where weak members in the
   // HashCountedSet are already swept out.
 
   if (m_finishedClients.contains(client))
-    m_finishedClients.remove(client);
+    m_finishedClients.erase(client);
   else if (m_clientsAwaitingCallback.contains(client))
-    m_clientsAwaitingCallback.remove(client);
+    m_clientsAwaitingCallback.erase(client);
   else
-    m_clients.remove(client);
+    m_clients.erase(client);
 
   if (m_clientsAwaitingCallback.isEmpty())
     ResourceCallback::callbackHandler().cancel(this);
 
   didRemoveClientOrObserver();
 }
 
 void Resource::didRemoveClientOrObserver() {
   if (!hasClientsOrObservers() && m_isAlive) {
     m_isAlive = false;
@@ skipping 50 matching lines @@
   //    available to be removed. Also don't call removed clients or add them
   //    back.
   //
   // Handle case (1) by saving a list of clients to notify. A separate list also
   // ensure a client is either in m_clients or m_clientsAwaitingCallback.
   HeapVector<Member<ResourceClient>> clientsToNotify;
   copyToVector(m_clientsAwaitingCallback, clientsToNotify);
 
   for (const auto& client : clientsToNotify) {
     // Handle case (2) to skip removed clients.
-    if (!m_clientsAwaitingCallback.remove(client))
+    if (!m_clientsAwaitingCallback.erase(client))
       continue;
     m_clients.insert(client);
 
     // When revalidation starts after waiting clients are scheduled and
     // before they are added here. In such cases, we just add the clients
     // to |m_clients| without didAddClient(), as in Resource::addClient().
     if (!m_isRevalidating)
       didAddClient(client);
   }
 
@@ skipping 292 matching lines @@
     case Resource::Media:
     case Resource::Manifest:
     case Resource::Mock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink