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.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,
+  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(int interface_index) 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