Add an UMA histogram for WebUSB function calls.

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"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/frame/UseCounter.h"
 #include "modules/webusb/USBConfiguration.h"
 #include "modules/webusb/USBControlTransferParameters.h"
 #include "modules/webusb/USBInTransferResult.h"
 #include "modules/webusb/USBIsochronousInTransferResult.h"
 #include "modules/webusb/USBIsochronousOutTransferResult.h"
 #include "modules/webusb/USBOutTransferResult.h"
 #include "platform/mojo/MojoHelper.h"
 #include "wtf/Assertions.h"
 
 namespace usb = device::usb::blink;
@@ skipping 104 matching lines @@
 {
     size_t numConfigurations = info().configurations.size();
     HeapVector<Member<USBConfiguration>> configurations(numConfigurations);
     for (size_t i = 0; i < numConfigurations; ++i)
         configurations[i] = USBConfiguration::create(this, i);
     return configurations;
 }
 
 ScriptPromise USBDevice::open(ScriptState* scriptState)
 {
+    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_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_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_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_device->ClaimInterface(interfaceNumber, convertToBaseCallback(WTF::bind(&USBDevice::asyncClaimInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::releaseInterface(ScriptState* scriptState, uint8_t interfaceNumber)
 {
+    UseCounter::count(scriptState->getExecutionContext(), UseCounter::UsbDeviceReleaseInterface);
+
     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, convertToBaseCallback(WTF::bind(&USBDevice::asyncReleaseInterface, wrapPersistent(this), interfaceIndex, wrapPersistent(resolver))));
         }
     }
     return promise;
 }
 
 ScriptPromise USBDevice::selectAlternateInterface(ScriptState* scriptState, uint8_t interfaceNumber, uint8_t alternateSetting)
 {
+    UseCounter::count(scriptState->getExecutionContext(), UseCounter::UsbDeviceSelectAlternateInterface);
+
     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, 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_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_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_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_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_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_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_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_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_device->Reset(convertToBaseCallback(WTF::bind(&USBDevice::asyncReset, wrapPersistent(this), wrapPersistent(resolver))));
         }
     }
@@ skipping 410 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