Migrate WTF::HashCountedSet::add() to ::insert()

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 352 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.add(client);
+    m_finishedClients.insert(client);
     m_clients.remove(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;
@@ skipping 268 matching lines @@
       builder.append(' ');
     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.add(c);
+      m_finishedClients.insert(c);
       m_clients.remove(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.
@@ skipping 32 matching lines @@
   }
 }
 
 void Resource::addClient(ResourceClient* client,
                          PreloadReferencePolicy policy) {
   CHECK(!m_isAddRemoveClientProhibited);
 
   willAddClientOrObserver(policy);
 
   if (m_isRevalidating) {
-    m_clients.add(client);
+    m_clients.insert(client);
     return;
   }
 
   // If an error has occurred or we have existing data to send to the new client
   // and the resource type supprts it, send it asynchronously.
   if ((errorOccurred() || !response().isNull()) &&
       !typeNeedsSynchronousCacheHit(getType()) && !m_needsSynchronousCacheHit) {
-    m_clientsAwaitingCallback.add(client);
+    m_clientsAwaitingCallback.insert(client);
     ResourceCallback::callbackHandler().schedule(this);
     return;
   }
 
-  m_clients.add(client);
+  m_clients.insert(client);
   didAddClient(client);
   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.
 
@@ skipping 68 matching lines @@
   //
   // 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))
       continue;
-    m_clients.add(client);
+    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);
   }
 
   // It is still possible for the above loop to finish a new client
   // synchronously. If there's no client waiting we should deschedule.
@@ skipping 290 matching lines @@
     case Resource::Media:
     case Resource::Manifest:
     case Resource::Mock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace blink