Migrate WTF::HashSet::add() to ::insert() [part 1 of N]

third_party/WebKit/Source/modules/webusb/USBDevice.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webusb/USBDevice.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ToV8.h"
 #include "core/dom/DOMArrayBuffer.h"
@@ skipping 136 matching lines @@
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceOpen);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
     if (m_opened) {
       resolver->resolve();
     } else {
       m_deviceStateChangeInProgress = true;
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->Open(convertToBaseCallback(
           WTF::bind(&USBDevice::asyncOpen, wrapPersistent(this),
                     wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::close(ScriptState* scriptState) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceClose);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
     if (!m_opened) {
       resolver->resolve();
     } else {
       m_deviceStateChangeInProgress = true;
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->Close(convertToBaseCallback(
           WTF::bind(&USBDevice::asyncClose, wrapPersistent(this),
                     wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::selectConfiguration(ScriptState* scriptState,
                                              uint8_t configurationValue) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceSelectConfiguration);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
     if (!m_opened) {
       resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
     } else {
       int configurationIndex = findConfigurationIndex(configurationValue);
       if (configurationIndex == -1) {
         resolver->reject(DOMException::create(NotFoundError,
                                               "The configuration value "
                                               "provided is not supported by "
                                               "the device."));
       } else if (m_configurationIndex == configurationIndex) {
         resolver->resolve();
       } else {
         m_deviceStateChangeInProgress = true;
-        m_deviceRequests.add(resolver);
+        m_deviceRequests.insert(resolver);
         m_device->SetConfiguration(
             configurationValue,
             convertToBaseCallback(WTF::bind(
                 &USBDevice::asyncSelectConfiguration, wrapPersistent(this),
                 configurationIndex, wrapPersistent(resolver))));
       }
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::claimInterface(ScriptState* scriptState,
                                         uint8_t interfaceNumber) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceClaimInterface);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureDeviceConfigured(resolver)) {
     int interfaceIndex = findInterfaceIndex(interfaceNumber);
     if (interfaceIndex == -1) {
       resolver->reject(DOMException::create(NotFoundError, kInterfaceNotFound));
     } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
       resolver->reject(DOMException::create(InvalidStateError,
                                             kInterfaceStateChangeInProgress));
     } else if (m_claimedInterfaces.get(interfaceIndex)) {
       resolver->resolve();
     } else {
       m_interfaceStateChangeInProgress.set(interfaceIndex);
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->ClaimInterface(
           interfaceNumber,
           convertToBaseCallback(WTF::bind(&USBDevice::asyncClaimInterface,
                                           wrapPersistent(this), interfaceIndex,
                                           wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
@@ skipping 14 matching lines @@
     } else if (m_interfaceStateChangeInProgress.get(interfaceIndex)) {
       resolver->reject(DOMException::create(InvalidStateError,
                                             kInterfaceStateChangeInProgress));
     } else if (!m_claimedInterfaces.get(interfaceIndex)) {
       resolver->resolve();
     } else {
       // Mark this interface's endpoints unavailable while its state is
       // changing.
       setEndpointsForInterface(interfaceIndex, false);
       m_interfaceStateChangeInProgress.set(interfaceIndex);
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->ReleaseInterface(
           interfaceNumber,
           convertToBaseCallback(WTF::bind(&USBDevice::asyncReleaseInterface,
                                           wrapPersistent(this), interfaceIndex,
                                           wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
@@ skipping 13 matching lines @@
     if (alternateIndex == -1) {
       resolver->reject(DOMException::create(NotFoundError,
                                             "The alternate setting provided is "
                                             "not supported by the device in "
                                             "its current configuration."));
     } else {
       // Mark this old alternate interface's endpoints unavailable while
       // the change is in progress.
       setEndpointsForInterface(interfaceIndex, false);
       m_interfaceStateChangeInProgress.set(interfaceIndex);
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->SetInterfaceAlternateSetting(
           interfaceNumber, alternateSetting,
           convertToBaseCallback(WTF::bind(
               &USBDevice::asyncSelectAlternateInterface, wrapPersistent(this),
               interfaceNumber, alternateSetting, wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::controlTransferIn(
     ScriptState* scriptState,
     const USBControlTransferParameters& setup,
     unsigned length) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceControlTransferIn);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureDeviceConfigured(resolver)) {
     auto parameters = convertControlTransferParameters(setup, resolver);
     if (parameters) {
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->ControlTransferIn(
           std::move(parameters), length, 0,
           convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferIn,
                                           wrapPersistent(this),
                                           wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(
     ScriptState* scriptState,
     const USBControlTransferParameters& setup) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceControlTransferOut);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureDeviceConfigured(resolver)) {
     auto parameters = convertControlTransferParameters(setup, resolver);
     if (parameters) {
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->ControlTransferOut(
           std::move(parameters), Vector<uint8_t>(), 0,
           convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut,
                                           wrapPersistent(this), 0,
                                           wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(
     ScriptState* scriptState,
     const USBControlTransferParameters& setup,
     const ArrayBufferOrArrayBufferView& data) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceControlTransferOut);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureDeviceConfigured(resolver)) {
     auto parameters = convertControlTransferParameters(setup, resolver);
     if (parameters) {
       Vector<uint8_t> buffer = convertBufferSource(data);
       unsigned transferLength = buffer.size();
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->ControlTransferOut(
           std::move(parameters), buffer, 0,
           convertToBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut,
                                           wrapPersistent(this), transferLength,
                                           wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 ScriptPromise USBDevice::clearHalt(ScriptState* scriptState,
                                    String direction,
                                    uint8_t endpointNumber) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceClearHalt);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureEndpointAvailable(direction == "in", endpointNumber, resolver)) {
-    m_deviceRequests.add(resolver);
+    m_deviceRequests.insert(resolver);
     m_device->ClearHalt(endpointNumber,
                         convertToBaseCallback(WTF::bind(
                             &USBDevice::asyncClearHalt, wrapPersistent(this),
                             wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USBDevice::transferIn(ScriptState* scriptState,
                                     uint8_t endpointNumber,
                                     unsigned length) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceTransferIn);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
-    m_deviceRequests.add(resolver);
+    m_deviceRequests.insert(resolver);
     m_device->GenericTransferIn(
         endpointNumber, length, 0,
         convertToBaseCallback(WTF::bind(&USBDevice::asyncTransferIn,
                                         wrapPersistent(this),
                                         wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USBDevice::transferOut(ScriptState* scriptState,
                                      uint8_t endpointNumber,
                                      const ArrayBufferOrArrayBufferView& data) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceTransferOut);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
     Vector<uint8_t> buffer = convertBufferSource(data);
     unsigned transferLength = buffer.size();
-    m_deviceRequests.add(resolver);
+    m_deviceRequests.insert(resolver);
     m_device->GenericTransferOut(
         endpointNumber, buffer, 0,
         convertToBaseCallback(WTF::bind(&USBDevice::asyncTransferOut,
                                         wrapPersistent(this), transferLength,
                                         wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferIn(ScriptState* scriptState,
                                                uint8_t endpointNumber,
                                                Vector<unsigned> packetLengths) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceIsochronousTransferIn);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
-    m_deviceRequests.add(resolver);
+    m_deviceRequests.insert(resolver);
     m_device->IsochronousTransferIn(
         endpointNumber, packetLengths, 0,
         convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferIn,
                                         wrapPersistent(this),
                                         wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferOut(
     ScriptState* scriptState,
     uint8_t endpointNumber,
     const ArrayBufferOrArrayBufferView& data,
     Vector<unsigned> packetLengths) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceIsochronousTransferOut);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
-    m_deviceRequests.add(resolver);
+    m_deviceRequests.insert(resolver);
     m_device->IsochronousTransferOut(
         endpointNumber, convertBufferSource(data), packetLengths, 0,
         convertToBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferOut,
                                         wrapPersistent(this),
                                         wrapPersistent(resolver))));
   }
   return promise;
 }
 
 ScriptPromise USBDevice::reset(ScriptState* scriptState) {
   UseCounter::count(scriptState->getExecutionContext(),
                     UseCounter::UsbDeviceReset);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
   if (ensureNoDeviceOrInterfaceChangeInProgress(resolver)) {
     if (!m_opened) {
       resolver->reject(DOMException::create(InvalidStateError, kOpenRequired));
     } else {
-      m_deviceRequests.add(resolver);
+      m_deviceRequests.insert(resolver);
       m_device->Reset(convertToBaseCallback(
           WTF::bind(&USBDevice::asyncReset, wrapPersistent(this),
                     wrapPersistent(resolver))));
     }
   }
   return promise;
 }
 
 void USBDevice::contextDestroyed(ExecutionContext*) {
   m_device.reset();
@@ skipping 453 matching lines @@
 
 bool USBDevice::markRequestComplete(ScriptPromiseResolver* resolver) {
   auto requestEntry = m_deviceRequests.find(resolver);
   if (requestEntry == m_deviceRequests.end())
     return false;
   m_deviceRequests.remove(requestEntry);
   return true;
 }
 
 }  // namespace blink