Specify WTF:: prefix for bind()

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 76 matching lines @@
 
 USBDevice::USBDevice(usb::DeviceInfoPtr deviceInfo, usb::DevicePtr device, ExecutionContext* context)
     : ContextLifecycleObserver(context)
     , m_deviceInfo(std::move(deviceInfo))
     , m_device(std::move(device))
     , m_opened(false)
     , m_deviceStateChangeInProgress(false)
     , m_configurationIndex(-1)
 {
     if (m_device)
-        m_device.set_connection_error_handler(createBaseCallback(bind(&USBDevice::onConnectionError, wrapWeakPersistent(this))));
+        m_device.set_connection_error_handler(createBaseCallback(WTF::bind(&USBDevice::onConnectionError, wrapWeakPersistent(this))));
     int configurationIndex = findConfigurationIndex(info().active_configuration);
     if (configurationIndex != -1)
         onConfigurationSelected(true /* success */, configurationIndex);
 }
 
 USBDevice::~USBDevice()
 {
     // |m_device| may still be valid but there should be no more outstanding
     // requests because each holds a persistent handle to this object.
     DCHECK(m_deviceRequests.isEmpty());
@@ skipping 28 matching lines @@
 ScriptPromise USBDevice::open(ScriptState* scriptState)
 {
     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_device->Open(createBaseCallback(bind(&USBDevice::asyncOpen, wrapPersistent(this), wrapPersistent(resolver))));
+            m_device->Open(createBaseCallback(WTF::bind(&USBDevice::asyncOpen, wrapPersistent(this), wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::close(ScriptState* scriptState)
 {
     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_device->Close(createBaseCallback(bind(&USBDevice::asyncClose, wrapPersistent(this), wrapPersistent(resolver))));
+            m_device->Close(createBaseCallback(WTF::bind(&USBDevice::asyncClose, wrapPersistent(this), wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectConfiguration(ScriptState* scriptState, uint8_t configurationValue)
 {
     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_device->SetConfiguration(configurationValue, createBaseCallback(bind(&USBDevice::asyncSelectConfiguration, wrapPersistent(this), configurationIndex, wrapPersistent(resolver))));
+                m_device->SetConfiguration(configurationValue, createBaseCallback(WTF::bind(&USBDevice::asyncSelectConfiguration, wrapPersistent(this), configurationIndex, wrapPersistent(resolver))));
             }
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::claimInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     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_device->ClaimInterface(interfaceNumber, createBaseCallback(bind(&USBDevice::asyncClaimInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
+            m_device->ClaimInterface(interfaceNumber, createBaseCallback(WTF::bind(&USBDevice::asyncClaimInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::releaseInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         int interfaceIndex = findInterfaceIndex(interfaceNumber);
         if (interfaceIndex == -1) {
             resolver->reject(DOMException::create(NotFoundError, "The interface number provided is not supported by the device in its current configuration."));
         } 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_device->ReleaseInterface(interfaceNumber, createBaseCallback(bind(&USBDevice::asyncReleaseInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
+            m_device->ReleaseInterface(interfaceNumber, createBaseCallback(WTF::bind(&USBDevice::asyncReleaseInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectAlternateInterface(ScriptState* scriptState, uint8_t interfaceNumber, uint8_t alternateSetting)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureInterfaceClaimed(interfaceNumber, resolver)) {
         // TODO(reillyg): This is duplicated work.
         int interfaceIndex = findInterfaceIndex(interfaceNumber);
         ASSERT(interfaceIndex != -1);
         int alternateIndex = findAlternateIndex(interfaceIndex, alternateSetting);
         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_device->SetInterfaceAlternateSetting(interfaceNumber, alternateSetting, createBaseCallback(bind(&USBDevice::asyncSelectAlternateInterface, wrapPersistent(this), interfaceNumber, alternateSetting, wrapPersistent(resolver))));
+            m_device->SetInterfaceAlternateSetting(interfaceNumber, alternateSetting, createBaseCallback(WTF::bind(&USBDevice::asyncSelectAlternateInterface, wrapPersistent(this), interfaceNumber, alternateSetting, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferIn(ScriptState* scriptState, const USBControlTransferParameters& setup, unsigned length)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         auto parameters = convertControlTransferParameters(setup, resolver);
         if (parameters) {
             m_deviceRequests.add(resolver);
-            m_device->ControlTransferIn(std::move(parameters), length, 0, createBaseCallback(bind(&USBDevice::asyncControlTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
+            m_device->ControlTransferIn(std::move(parameters), length, 0, createBaseCallback(WTF::bind(&USBDevice::asyncControlTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBControlTransferParameters& setup)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         auto parameters = convertControlTransferParameters(setup, resolver);
         if (parameters) {
             m_deviceRequests.add(resolver);
-            m_device->ControlTransferOut(std::move(parameters), mojo::WTFArray<uint8_t>(), 0, createBaseCallback(bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), 0, wrapPersistent(resolver))));
+            m_device->ControlTransferOut(std::move(parameters), mojo::WTFArray<uint8_t>(), 0, createBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), 0, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBControlTransferParameters& setup, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureDeviceConfigured(resolver)) {
         auto parameters = convertControlTransferParameters(setup, resolver);
         if (parameters) {
             mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
             unsigned transferLength = buffer.size();
             m_deviceRequests.add(resolver);
-            m_device->ControlTransferOut(std::move(parameters), std::move(buffer), 0, createBaseCallback(bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
+            m_device->ControlTransferOut(std::move(parameters), std::move(buffer), 0, createBaseCallback(WTF::bind(&USBDevice::asyncControlTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, String direction, uint8_t endpointNumber)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureEndpointAvailable(direction == "in", endpointNumber, resolver)) {
         m_deviceRequests.add(resolver);
-        m_device->ClearHalt(endpointNumber, createBaseCallback(bind(&USBDevice::asyncClearHalt, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->ClearHalt(endpointNumber, createBaseCallback(WTF::bind(&USBDevice::asyncClearHalt, wrapPersistent(this), wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::transferIn(ScriptState* scriptState, uint8_t endpointNumber, unsigned length)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
         m_deviceRequests.add(resolver);
-        m_device->GenericTransferIn(endpointNumber, length, 0, createBaseCallback(bind(&USBDevice::asyncTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->GenericTransferIn(endpointNumber, length, 0, createBaseCallback(WTF::bind(&USBDevice::asyncTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::transferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
         mojo::WTFArray<uint8_t> buffer = convertBufferSource(data);
         unsigned transferLength = buffer.size();
         m_deviceRequests.add(resolver);
-        m_device->GenericTransferOut(endpointNumber, std::move(buffer), 0, createBaseCallback(bind(&USBDevice::asyncTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
+        m_device->GenericTransferOut(endpointNumber, std::move(buffer), 0, createBaseCallback(WTF::bind(&USBDevice::asyncTransferOut, wrapPersistent(this), transferLength, wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferIn(ScriptState* scriptState, uint8_t endpointNumber, Vector<unsigned> packetLengths)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureEndpointAvailable(true /* in */, endpointNumber, resolver)) {
         m_deviceRequests.add(resolver);
-        m_device->IsochronousTransferIn(endpointNumber, mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, createBaseCallback(bind(&USBDevice::asyncIsochronousTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->IsochronousTransferIn(endpointNumber, mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, createBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferIn, wrapPersistent(this), wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::isochronousTransferOut(ScriptState* scriptState, uint8_t endpointNumber, const ArrayBufferOrArrayBufferView& data, Vector<unsigned> packetLengths)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     if (ensureEndpointAvailable(false /* out */, endpointNumber, resolver)) {
         m_deviceRequests.add(resolver);
-        m_device->IsochronousTransferOut(endpointNumber, convertBufferSource(data), mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, createBaseCallback(bind(&USBDevice::asyncIsochronousTransferOut, wrapPersistent(this), wrapPersistent(resolver))));
+        m_device->IsochronousTransferOut(endpointNumber, convertBufferSource(data), mojo::WTFArray<uint32_t>(std::move(packetLengths)), 0, createBaseCallback(WTF::bind(&USBDevice::asyncIsochronousTransferOut, wrapPersistent(this), wrapPersistent(resolver))));
     }
     return promise;
 }
 
 ScriptPromise USBDevice::reset(ScriptState* scriptState)
 {
     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_device->Reset(createBaseCallback(bind(&USBDevice::asyncReset, wrapPersistent(this), wrapPersistent(resolver))));
+            m_device->Reset(createBaseCallback(WTF::bind(&USBDevice::asyncReset, wrapPersistent(this), wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 void USBDevice::contextDestroyed()
 {
     m_device.reset();
     m_deviceRequests.clear();
 }
@@ skipping 402 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