Fix 64 bit truncation errors in blink/renderer/modules/webusb

Use wtf_size_t when dealing with WTF types.

BUG=879657

Change-Id: Ic2eec59581223c897b76675a2d7b1fb47a1327da
Reviewed-on: https://chromium-review.googlesource.com/c/1257681
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596208}

third_party/blink/renderer/modules/webusb/usb_alternate_interface.cc

@@ -12,16 +12,16 @@ namespace blink {
 
 USBAlternateInterface* USBAlternateInterface::Create(
     const USBInterface* interface,
-    size_t alternate_index) {
+    wtf_size_t alternate_index) {
   return new USBAlternateInterface(interface, alternate_index);
 }
 
 USBAlternateInterface* USBAlternateInterface::Create(
     const USBInterface* interface,
-    size_t alternate_setting,
+    uint8_t alternate_setting,
     ExceptionState& exception_state) {
   const auto& alternates = interface->Info().alternates;
-  for (size_t i = 0; i < alternates.size(); ++i) {
+  for (wtf_size_t i = 0; i < alternates.size(); ++i) {
     if (alternates[i]->alternate_setting == alternate_setting)
       return USBAlternateInterface::Create(interface, i);
   }
@@ -30,7 +30,7 @@ USBAlternateInterface* USBAlternateInterface::Create(
 }
 
 USBAlternateInterface::USBAlternateInterface(const USBInterface* interface,
-                                             size_t alternate_index)
+                                             wtf_size_t alternate_index)
     : interface_(interface), alternate_index_(alternate_index) {
   DCHECK(interface_);
   DCHECK_LT(alternate_index_, interface_->Info().alternates.size());
@@ -46,7 +46,7 @@ USBAlternateInterface::Info() const {
 
 HeapVector<Member<USBEndpoint>> USBAlternateInterface::endpoints() const {
   HeapVector<Member<USBEndpoint>> endpoints;
-  for (size_t i = 0; i < Info().endpoints.size(); ++i)
+  for (wtf_size_t i = 0; i < Info().endpoints.size(); ++i)
     endpoints.push_back(USBEndpoint::Create(this, i));
   return endpoints;
 }

third_party/blink/renderer/modules/webusb/usb_alternate_interface.h

@@ -20,12 +20,12 @@ class USBAlternateInterface : public ScriptWrappable {
 
  public:
   static USBAlternateInterface* Create(const USBInterface*,
-                                       size_t alternate_index);
+                                       wtf_size_t alternate_index);
   static USBAlternateInterface* Create(const USBInterface*,
-                                       size_t alternate_setting,
+                                       uint8_t alternate_setting,
                                        ExceptionState&);
 
-  USBAlternateInterface(const USBInterface*, size_t alternate_index);
+  USBAlternateInterface(const USBInterface*, wtf_size_t alternate_index);
 
   const device::mojom::blink::UsbAlternateInterfaceInfo& Info() const;
 
@@ -40,7 +40,7 @@ class USBAlternateInterface : public ScriptWrappable {
 
  private:
   Member<const USBInterface> interface_;
-  const size_t alternate_index_;
+  const wtf_size_t alternate_index_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/webusb/usb_configuration.cc

@@ -12,15 +12,15 @@
 namespace blink {
 
 USBConfiguration* USBConfiguration::Create(const USBDevice* device,
-                                           size_t configuration_index) {
+                                           wtf_size_t configuration_index) {
   return new USBConfiguration(device, configuration_index);
 }
 
 USBConfiguration* USBConfiguration::Create(const USBDevice* device,
-                                           size_t configuration_value,
+                                           uint8_t configuration_value,
                                            ExceptionState& exception_state) {
   const auto& configurations = device->Info().configurations;
-  for (size_t i = 0; i < configurations.size(); ++i) {
+  for (wtf_size_t i = 0; i < configurations.size(); ++i) {
     if (configurations[i]->configuration_value == configuration_value)
       return new USBConfiguration(device, i);
   }
@@ -29,7 +29,7 @@ USBConfiguration* USBConfiguration::Create(const USBDevice* device,
 }
 
 USBConfiguration::USBConfiguration(const USBDevice* device,
-                                   size_t configuration_index)
+                                   wtf_size_t configuration_index)
     : device_(device), configuration_index_(configuration_index) {
   DCHECK(device_);
   DCHECK_LT(configuration_index_, device_->Info().configurations.size());
@@ -39,7 +39,7 @@ const USBDevice* USBConfiguration::Device() const {
   return device_;
 }
 
-size_t USBConfiguration::Index() const {
+wtf_size_t USBConfiguration::Index() const {
   return configuration_index_;
 }
 
@@ -50,7 +50,7 @@ const device::mojom::blink::UsbConfigurationInfo& USBConfiguration::Info()
 
 HeapVector<Member<USBInterface>> USBConfiguration::interfaces() const {
   HeapVector<Member<USBInterface>> interfaces;
-  for (size_t i = 0; i < Info().interfaces.size(); ++i)
+  for (wtf_size_t i = 0; i < Info().interfaces.size(); ++i)
     interfaces.push_back(USBInterface::Create(this, i));
   return interfaces;
 }

third_party/blink/renderer/modules/webusb/usb_configuration.h

@@ -19,15 +19,16 @@ class USBConfiguration : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static USBConfiguration* Create(const USBDevice*, size_t configuration_index);
   static USBConfiguration* Create(const USBDevice*,
-                                  size_t configuration_value,
+                                  wtf_size_t configuration_index);
+  static USBConfiguration* Create(const USBDevice*,
+                                  uint8_t configuration_value,
                                   ExceptionState&);
 
-  USBConfiguration(const USBDevice*, size_t configuration_index);
+  USBConfiguration(const USBDevice*, wtf_size_t configuration_index);
 
   const USBDevice* Device() const;
-  size_t Index() const;
+  wtf_size_t Index() const;
   const device::mojom::blink::UsbConfigurationInfo& Info() const;
 
   uint8_t configurationValue() const { return Info().configuration_value; }
@@ -38,7 +39,7 @@ class USBConfiguration : public ScriptWrappable {
 
  private:
   Member<const USBDevice> device_;
-  const size_t configuration_index_;
+  const wtf_size_t configuration_index_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/webusb/usb_device.cc

@@ -116,13 +116,14 @@ USBDevice::USBDevice(UsbDeviceInfoPtr device_info,
       device_(std::move(device)),
       opened_(false),
       device_state_change_in_progress_(false),
-      configuration_index_(-1) {
+      configuration_index_(kNotFound) {
   if (device_) {
     device_.set_connection_error_handler(
         WTF::Bind(&USBDevice::OnConnectionError, WrapWeakPersistent(this)));
   }
-  int configuration_index = FindConfigurationIndex(Info().active_configuration);
-  if (configuration_index != -1)
+  wtf_size_t configuration_index =
+      FindConfigurationIndex(Info().active_configuration);
+  if (configuration_index != kNotFound)
     OnConfigurationSelected(true /* success */, configuration_index);
 }
 
@@ -132,27 +133,28 @@ USBDevice::~USBDevice() {
   DCHECK(device_requests_.IsEmpty());
 }
 
-bool USBDevice::IsInterfaceClaimed(size_t configuration_index,
-                                   size_t interface_index) const {
-  return configuration_index_ != -1 &&
-         static_cast<size_t>(configuration_index_) == configuration_index &&
+bool USBDevice::IsInterfaceClaimed(wtf_size_t configuration_index,
+                                   wtf_size_t interface_index) const {
+  return configuration_index_ != kNotFound &&
+         configuration_index_ == configuration_index &&
          claimed_interfaces_.Get(interface_index);
 }
 
-size_t USBDevice::SelectedAlternateInterface(size_t interface_index) const {
+wtf_size_t USBDevice::SelectedAlternateInterface(
+    wtf_size_t interface_index) const {
   return selected_alternates_[interface_index];
 }
 
 USBConfiguration* USBDevice::configuration() const {
-  if (configuration_index_ != -1)
+  if (configuration_index_ != kNotFound)
     return USBConfiguration::Create(this, configuration_index_);
   return nullptr;
 }
 
 HeapVector<Member<USBConfiguration>> USBDevice::configurations() const {
-  size_t num_configurations = Info().configurations.size();
+  wtf_size_t num_configurations = Info().configurations.size();
   HeapVector<Member<USBConfiguration>> configurations(num_configurations);
-  for (size_t i = 0; i < num_configurations; ++i)
+  for (wtf_size_t i = 0; i < num_configurations; ++i)
     configurations[i] = USBConfiguration::Create(this, i);
   return configurations;
 }
@@ -198,8 +200,9 @@ ScriptPromise USBDevice::selectConfiguration(ScriptState* script_state,
       resolver->Reject(DOMException::Create(
           DOMExceptionCode::kInvalidStateError, kOpenRequired));
     } else {
-      int configuration_index = FindConfigurationIndex(configuration_value);
-      if (configuration_index == -1) {
+      wtf_size_t configuration_index =
+          FindConfigurationIndex(configuration_value);
+      if (configuration_index == kNotFound) {
         resolver->Reject(DOMException::Create(DOMExceptionCode::kNotFoundError,
                                               "The configuration value "
                                               "provided is not supported by "
@@ -225,8 +228,8 @@ ScriptPromise USBDevice::claimInterface(ScriptState* script_state,
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (EnsureDeviceConfigured(resolver)) {
-    int interface_index = FindInterfaceIndex(interface_number);
-    if (interface_index == -1) {
+    wtf_size_t interface_index = FindInterfaceIndex(interface_number);
+    if (interface_index == kNotFound) {
       resolver->Reject(DOMException::Create(DOMExceptionCode::kNotFoundError,
                                             kInterfaceNotFound));
     } else if (interface_state_change_in_progress_.Get(interface_index)) {
@@ -261,8 +264,8 @@ ScriptPromise USBDevice::releaseInterface(ScriptState* script_state,
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (EnsureDeviceConfigured(resolver)) {
-    int interface_index = FindInterfaceIndex(interface_number);
-    if (interface_index == -1) {
+    wtf_size_t interface_index = FindInterfaceIndex(interface_number);
+    if (interface_index == kNotFound) {
       resolver->Reject(DOMException::Create(DOMExceptionCode::kNotFoundError,
                                             "The interface number provided is "
                                             "not supported by the device in "
@@ -295,11 +298,11 @@ ScriptPromise USBDevice::selectAlternateInterface(ScriptState* script_state,
   ScriptPromise promise = resolver->Promise();
   if (EnsureInterfaceClaimed(interface_number, resolver)) {
     // TODO(reillyg): This is duplicated work.
-    int interface_index = FindInterfaceIndex(interface_number);
-    DCHECK_NE(interface_index, -1);
-    int alternate_index =
+    wtf_size_t interface_index = FindInterfaceIndex(interface_number);
+    DCHECK_NE(interface_index, kNotFound);
+    wtf_size_t alternate_index =
         FindAlternateIndex(interface_index, alternate_setting);
-    if (alternate_index == -1) {
+    if (alternate_index == kNotFound) {
       resolver->Reject(DOMException::Create(DOMExceptionCode::kNotFoundError,
                                             "The alternate setting provided is "
                                             "not supported by the device in "
@@ -484,43 +487,44 @@ void USBDevice::Trace(blink::Visitor* visitor) {
   ContextLifecycleObserver::Trace(visitor);
 }
 
-int USBDevice::FindConfigurationIndex(uint8_t configuration_value) const {
+wtf_size_t USBDevice::FindConfigurationIndex(
+    uint8_t configuration_value) const {
   const auto& configurations = Info().configurations;
-  for (size_t i = 0; i < configurations.size(); ++i) {
+  for (wtf_size_t i = 0; i < configurations.size(); ++i) {
     if (configurations[i]->configuration_value == configuration_value)
       return i;
   }
-  return -1;
+  return kNotFound;
 }
 
-int USBDevice::FindInterfaceIndex(uint8_t interface_number) const {
-  DCHECK_NE(configuration_index_, -1);
+wtf_size_t USBDevice::FindInterfaceIndex(uint8_t interface_number) const {
+  DCHECK_NE(configuration_index_, kNotFound);
   const auto& interfaces =
       Info().configurations[configuration_index_]->interfaces;
-  for (size_t i = 0; i < interfaces.size(); ++i) {
+  for (wtf_size_t i = 0; i < interfaces.size(); ++i) {
     if (interfaces[i]->interface_number == interface_number)
       return i;
   }
-  return -1;
+  return kNotFound;
 }
 
-int USBDevice::FindAlternateIndex(size_t interface_index,
-                                  uint8_t alternate_setting) const {
-  DCHECK_NE(configuration_index_, -1);
+wtf_size_t USBDevice::FindAlternateIndex(uint32_t interface_index,
+                                         uint8_t alternate_setting) const {
+  DCHECK_NE(configuration_index_, kNotFound);
   const auto& alternates = Info()
                                .configurations[configuration_index_]
                                ->interfaces[interface_index]
                                ->alternates;
-  for (size_t i = 0; i < alternates.size(); ++i) {
+  for (wtf_size_t i = 0; i < alternates.size(); ++i) {
     if (alternates[i]->alternate_setting == alternate_setting)
       return i;
   }
-  return -1;
+  return kNotFound;
 }
 
-bool USBDevice::IsProtectedInterfaceClass(int interface_index) const {
-  DCHECK_NE(configuration_index_, -1);
-  DCHECK_NE(interface_index, -1);
+bool USBDevice::IsProtectedInterfaceClass(wtf_size_t interface_index) const {
+  DCHECK_NE(configuration_index_, kNotFound);
+  DCHECK_NE(interface_index, kNotFound);
 
   // USB Class Codes are defined by the USB-IF:
   // http://www.usb.org/developers/defined_class
@@ -578,7 +582,7 @@ bool USBDevice::EnsureDeviceConfigured(ScriptPromiseResolver* resolver) const {
   } else if (!opened_) {
     resolver->Reject(DOMException::Create(DOMExceptionCode::kInvalidStateError,
                                           kOpenRequired));
-  } else if (configuration_index_ == -1) {
+  } else if (configuration_index_ == kNotFound) {
     resolver->Reject(
         DOMException::Create(DOMExceptionCode::kInvalidStateError,
                              "The device must have a configuration selected."));
@@ -592,8 +596,8 @@ bool USBDevice::EnsureInterfaceClaimed(uint8_t interface_number,
                                        ScriptPromiseResolver* resolver) const {
   if (!EnsureDeviceConfigured(resolver))
     return false;
-  int interface_index = FindInterfaceIndex(interface_number);
-  if (interface_index == -1) {
+  wtf_size_t interface_index = FindInterfaceIndex(interface_number);
+  if (interface_index == kNotFound) {
     resolver->Reject(DOMException::Create(DOMExceptionCode::kNotFoundError,
                                           kInterfaceNotFound));
   } else if (interface_state_change_in_progress_.Get(interface_index)) {
@@ -632,7 +636,7 @@ bool USBDevice::EnsureEndpointAvailable(bool in_transfer,
 }
 
 bool USBDevice::AnyInterfaceChangeInProgress() const {
-  for (size_t i = 0; i < interface_state_change_in_progress_.size(); ++i) {
+  for (wtf_size_t i = 0; i < interface_state_change_in_progress_.size(); ++i) {
     if (interface_state_change_in_progress_.QuickGet(i))
       return true;
   }
@@ -660,13 +664,13 @@ UsbControlTransferParamsPtr USBDevice::ConvertControlTransferParameters(
   if (parameters.recipient() == "device") {
     mojo_parameters->recipient = UsbControlTransferRecipient::DEVICE;
   } else if (parameters.recipient() == "interface") {
-    size_t interface_number = parameters.index() & 0xff;
+    uint8_t interface_number = parameters.index() & 0xff;
     if (!EnsureInterfaceClaimed(interface_number, resolver))
       return nullptr;
     mojo_parameters->recipient = UsbControlTransferRecipient::INTERFACE;
   } else if (parameters.recipient() == "endpoint") {
     bool in_transfer = parameters.index() & 0x80;
-    size_t endpoint_number = parameters.index() & 0x0f;
+    uint8_t endpoint_number = parameters.index() & 0x0f;
     if (!EnsureEndpointAvailable(in_transfer, endpoint_number, resolver))
       return nullptr;
     mojo_parameters->recipient = UsbControlTransferRecipient::ENDPOINT;
@@ -685,7 +689,7 @@ UsbControlTransferParamsPtr USBDevice::ConvertControlTransferParameters(
   return mojo_parameters;
 }
 
-void USBDevice::SetEndpointsForInterface(size_t interface_index, bool set) {
+void USBDevice::SetEndpointsForInterface(wtf_size_t interface_index, bool set) {
   const auto& configuration = *Info().configurations[configuration_index_];
   const auto& interface = *configuration.interfaces[interface_index];
   const auto& alternate =
@@ -744,7 +748,7 @@ void USBDevice::OnDeviceOpenedOrClosed(bool opened) {
   device_state_change_in_progress_ = false;
 }
 
-void USBDevice::AsyncSelectConfiguration(size_t configuration_index,
+void USBDevice::AsyncSelectConfiguration(wtf_size_t configuration_index,
                                          ScriptPromiseResolver* resolver,
                                          bool success) {
   if (!MarkRequestComplete(resolver))
@@ -761,10 +765,10 @@ void USBDevice::AsyncSelectConfiguration(size_t configuration_index,
 }
 
 void USBDevice::OnConfigurationSelected(bool success,
-                                        size_t configuration_index) {
+                                        wtf_size_t configuration_index) {
   if (success) {
     configuration_index_ = configuration_index;
-    size_t num_interfaces =
+    wtf_size_t num_interfaces =
         Info().configurations[configuration_index_]->interfaces.size();
     claimed_interfaces_.ClearAll();
     claimed_interfaces_.Resize(num_interfaces);
@@ -778,7 +782,7 @@ void USBDevice::OnConfigurationSelected(bool success,
   device_state_change_in_progress_ = false;
 }
 
-void USBDevice::AsyncClaimInterface(size_t interface_index,
+void USBDevice::AsyncClaimInterface(wtf_size_t interface_index,
                                     ScriptPromiseResolver* resolver,
                                     bool success) {
   if (!MarkRequestComplete(resolver))
@@ -793,7 +797,7 @@ void USBDevice::AsyncClaimInterface(size_t interface_index,
   }
 }
 
-void USBDevice::AsyncReleaseInterface(size_t interface_index,
+void USBDevice::AsyncReleaseInterface(wtf_size_t interface_index,
                                       ScriptPromiseResolver* resolver,
                                       bool success) {
   if (!MarkRequestComplete(resolver))
@@ -809,7 +813,7 @@ void USBDevice::AsyncReleaseInterface(size_t interface_index,
 }
 
 void USBDevice::OnInterfaceClaimedOrUnclaimed(bool claimed,
-                                              size_t interface_index) {
+                                              wtf_size_t interface_index) {
   if (claimed) {
     claimed_interfaces_.Set(interface_index);
   } else {
@@ -820,8 +824,8 @@ void USBDevice::OnInterfaceClaimedOrUnclaimed(bool claimed,
   interface_state_change_in_progress_.Clear(interface_index);
 }
 
-void USBDevice::AsyncSelectAlternateInterface(size_t interface_index,
-                                              size_t alternate_index,
+void USBDevice::AsyncSelectAlternateInterface(wtf_size_t interface_index,
+                                              wtf_size_t alternate_index,
                                               ScriptPromiseResolver* resolver,
                                               bool success) {
   if (!MarkRequestComplete(resolver))

third_party/blink/renderer/modules/webusb/usb_device.h

@@ -40,9 +40,9 @@ class USBDevice : public ScriptWrappable, public ContextLifecycleObserver {
   const device::mojom::blink::UsbDeviceInfo& Info() const {
     return *device_info_;
   }
-  bool IsInterfaceClaimed(size_t configuration_index,
-                          size_t interface_index) const;
-  size_t SelectedAlternateInterface(size_t interface_index) const;
+  bool IsInterfaceClaimed(wtf_size_t configuration_index,
+                          wtf_size_t interface_index) const;
+  wtf_size_t SelectedAlternateInterface(wtf_size_t interface_index) const;
 
   // USBDevice.idl
   uint8_t usbVersionMajor() const { return Info().usb_version_major; }
@@ -105,11 +105,11 @@ class USBDevice : public ScriptWrappable, public ContextLifecycleObserver {
   void Trace(blink::Visitor*) override;
 
  private:
-  int FindConfigurationIndex(uint8_t configuration_value) const;
-  int FindInterfaceIndex(uint8_t interface_number) const;
-  int FindAlternateIndex(size_t interface_index,
-                         uint8_t alternate_setting) const;
-  bool IsProtectedInterfaceClass(int interface_index) const;
+  wtf_size_t FindConfigurationIndex(uint8_t configuration_value) const;
+  wtf_size_t FindInterfaceIndex(uint8_t interface_number) const;
+  wtf_size_t FindAlternateIndex(wtf_size_t interface_index,
+                                uint8_t alternate_setting) const;
+  bool IsProtectedInterfaceClass(wtf_size_t interface_index) const;
   bool EnsureNoDeviceOrInterfaceChangeInProgress(ScriptPromiseResolver*) const;
   bool EnsureDeviceConfigured(ScriptPromiseResolver*) const;
   bool EnsureInterfaceClaimed(uint8_t interface_number,
@@ -121,25 +121,25 @@ class USBDevice : public ScriptWrappable, public ContextLifecycleObserver {
   device::mojom::blink::UsbControlTransferParamsPtr
   ConvertControlTransferParameters(const USBControlTransferParameters&,
                                    ScriptPromiseResolver*) const;
-  void SetEndpointsForInterface(size_t interface_index, bool set);
+  void SetEndpointsForInterface(wtf_size_t interface_index, bool set);
 
   void AsyncOpen(ScriptPromiseResolver*,
                  device::mojom::blink::UsbOpenDeviceError);
   void AsyncClose(ScriptPromiseResolver*);
   void OnDeviceOpenedOrClosed(bool);
-  void AsyncSelectConfiguration(size_t configuration_index,
+  void AsyncSelectConfiguration(wtf_size_t configuration_index,
                                 ScriptPromiseResolver*,
                                 bool success);
-  void OnConfigurationSelected(bool success, size_t configuration_index);
-  void AsyncClaimInterface(size_t interface_index,
+  void OnConfigurationSelected(bool success, wtf_size_t configuration_index);
+  void AsyncClaimInterface(wtf_size_t interface_index,
                            ScriptPromiseResolver*,
                            bool success);
-  void AsyncReleaseInterface(size_t interface_index,
+  void AsyncReleaseInterface(wtf_size_t interface_index,
                              ScriptPromiseResolver*,
                              bool success);
-  void OnInterfaceClaimedOrUnclaimed(bool claimed, size_t interface_index);
-  void AsyncSelectAlternateInterface(size_t interface_index,
-                                     size_t alternate_index,
+  void OnInterfaceClaimedOrUnclaimed(bool claimed, wtf_size_t interface_index);
+  void AsyncSelectAlternateInterface(wtf_size_t interface_index,
+                                     wtf_size_t alternate_index,
                                      ScriptPromiseResolver*,
                                      bool success);
   void AsyncControlTransferIn(ScriptPromiseResolver*,
@@ -172,10 +172,10 @@ class USBDevice : public ScriptWrappable, public ContextLifecycleObserver {
   HeapHashSet<Member<ScriptPromiseResolver>> device_requests_;
   bool opened_;
   bool device_state_change_in_progress_;
-  int configuration_index_;
+  wtf_size_t configuration_index_;
   WTF::BitVector claimed_interfaces_;
   WTF::BitVector interface_state_change_in_progress_;
-  WTF::Vector<size_t> selected_alternates_;
+  WTF::Vector<wtf_size_t> selected_alternates_;
   WTF::BitVector in_endpoints_;
   WTF::BitVector out_endpoints_;
 };

third_party/blink/renderer/modules/webusb/usb_endpoint.cc

@@ -45,19 +45,19 @@ String ConvertTypeToEnum(const UsbTransferType& type) {
 }  // namespace
 
 USBEndpoint* USBEndpoint::Create(const USBAlternateInterface* alternate,
-                                 size_t endpoint_index) {
+                                 wtf_size_t endpoint_index) {
   return new USBEndpoint(alternate, endpoint_index);
 }
 
 USBEndpoint* USBEndpoint::Create(const USBAlternateInterface* alternate,
-                                 size_t endpoint_number,
+                                 uint8_t endpoint_number,
                                  const String& direction,
                                  ExceptionState& exception_state) {
   UsbTransferDirection mojo_direction = direction == "in"
                                             ? UsbTransferDirection::INBOUND
                                             : UsbTransferDirection::OUTBOUND;
   const auto& endpoints = alternate->Info().endpoints;
-  for (size_t i = 0; i < endpoints.size(); ++i) {
+  for (wtf_size_t i = 0; i < endpoints.size(); ++i) {
     const auto& endpoint = endpoints[i];
     if (endpoint->endpoint_number == endpoint_number &&
         endpoint->direction == mojo_direction)
@@ -69,7 +69,7 @@ USBEndpoint* USBEndpoint::Create(const USBAlternateInterface* alternate,
 }
 
 USBEndpoint::USBEndpoint(const USBAlternateInterface* alternate,
-                         size_t endpoint_index)
+                         wtf_size_t endpoint_index)
     : alternate_(alternate), endpoint_index_(endpoint_index) {
   DCHECK(alternate_);
   DCHECK_LT(endpoint_index_, alternate_->Info().endpoints.size());

third_party/blink/renderer/modules/webusb/usb_endpoint.h

@@ -19,13 +19,13 @@ class USBEndpoint : public ScriptWrappable {
 
  public:
   static USBEndpoint* Create(const USBAlternateInterface*,
-                             size_t endpoint_index);
+                             wtf_size_t endpoint_index);
   static USBEndpoint* Create(const USBAlternateInterface*,
-                             size_t endpoint_number,
+                             uint8_t endpoint_number,
                              const String& direction,
                              ExceptionState&);
 
-  USBEndpoint(const USBAlternateInterface*, size_t endpoint_index);
+  USBEndpoint(const USBAlternateInterface*, wtf_size_t endpoint_index);
 
   const device::mojom::blink::UsbEndpointInfo& Info() const;
 
@@ -38,7 +38,7 @@ class USBEndpoint : public ScriptWrappable {
 
  private:
   Member<const USBAlternateInterface> alternate_;
-  const size_t endpoint_index_;
+  const wtf_size_t endpoint_index_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/webusb/usb_interface.cc

@@ -13,16 +13,16 @@
 namespace blink {
 
 USBInterface* USBInterface::Create(const USBConfiguration* configuration,
-                                   size_t interface_index) {
+                                   wtf_size_t interface_index) {
   return new USBInterface(configuration->Device(), configuration->Index(),
                           interface_index);
 }
 
 USBInterface* USBInterface::Create(const USBConfiguration* configuration,
-                                   size_t interface_number,
+                                   uint8_t interface_number,
                                    ExceptionState& exception_state) {
   const auto& interfaces = configuration->Info().interfaces;
-  for (size_t i = 0; i < interfaces.size(); ++i) {
+  for (wtf_size_t i = 0; i < interfaces.size(); ++i) {
     if (interfaces[i]->interface_number == interface_number)
       return new USBInterface(configuration->Device(), configuration->Index(),
                               i);
@@ -32,8 +32,8 @@ USBInterface* USBInterface::Create(const USBConfiguration* configuration,
 }
 
 USBInterface::USBInterface(const USBDevice* device,
-                           size_t configuration_index,
-                           size_t interface_index)
+                           wtf_size_t configuration_index,
+                           wtf_size_t interface_index)
     : device_(device),
       configuration_index_(configuration_index),
       interface_index_(interface_index) {
@@ -58,7 +58,7 @@ USBAlternateInterface* USBInterface::alternate() const {
 
 HeapVector<Member<USBAlternateInterface>> USBInterface::alternates() const {
   HeapVector<Member<USBAlternateInterface>> alternates;
-  for (size_t i = 0; i < Info().alternates.size(); ++i)
+  for (wtf_size_t i = 0; i < Info().alternates.size(); ++i)
     alternates.push_back(USBAlternateInterface::Create(this, i));
   return alternates;
 }

third_party/blink/renderer/modules/webusb/usb_interface.h

@@ -20,14 +20,15 @@ class USBInterface : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static USBInterface* Create(const USBConfiguration*, size_t interface_index);
   static USBInterface* Create(const USBConfiguration*,
-                              size_t interface_number,
+                              wtf_size_t interface_index);
+  static USBInterface* Create(const USBConfiguration*,
+                              uint8_t interface_number,
                               ExceptionState&);
 
   USBInterface(const USBDevice*,
-               size_t configuration_index,
-               size_t interface_index);
+               wtf_size_t configuration_index,
+               wtf_size_t interface_index);
 
   const device::mojom::blink::UsbInterfaceInfo& Info() const;
 
@@ -40,8 +41,8 @@ class USBInterface : public ScriptWrappable {
 
  private:
   Member<const USBDevice> device_;
-  const size_t configuration_index_;
-  const size_t interface_index_;
+  const wtf_size_t configuration_index_;
+  const wtf_size_t interface_index_;
 };
 
 }  // namespace blink