Switch to standard integer types in content/browser/.

content/browser/gamepad/xbox_data_fetcher_mac.cc

 // Copyright 2013 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 "content/browser/gamepad/xbox_data_fetcher_mac.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 51 matching lines @@
   bool bumper_left  : 1;
   bool bumper_right : 1;
   bool guide        : 1;
   bool dummy1       : 1;  // Always 0.
 
   bool a : 1;
   bool b : 1;
   bool x : 1;
   bool y : 1;
 
-  uint8 trigger_left;
-  uint8 trigger_right;
+  uint8_t trigger_left;
+  uint8_t trigger_right;
 
-  int16 stick_left_x;
-  int16 stick_left_y;
-  int16 stick_right_x;
-  int16 stick_right_y;
+  int16_t stick_left_x;
+  int16_t stick_left_y;
+  int16_t stick_right_x;
+  int16_t stick_right_y;
 
   // Always 0.
-  uint32 dummy2;
-  uint16 dummy3;
+  uint32_t dummy2;
+  uint16_t dummy3;
 };
 
 struct XboxOneButtonData {
   bool sync   : 1;
   bool dummy1 : 1;  // Always 0.
   bool start  : 1;
   bool back   : 1;
 
   bool a : 1;
   bool b : 1;
   bool x : 1;
   bool y : 1;
 
   bool dpad_up    : 1;
   bool dpad_down  : 1;
   bool dpad_left  : 1;
   bool dpad_right : 1;
 
   bool bumper_left       : 1;
   bool bumper_right      : 1;
   bool stick_left_click  : 1;
   bool stick_right_click : 1;
 
-  uint16 trigger_left;
-  uint16 trigger_right;
+  uint16_t trigger_left;
+  uint16_t trigger_right;
 
-  int16 stick_left_x;
-  int16 stick_left_y;
-  int16 stick_right_x;
-  int16 stick_right_y;
+  int16_t stick_left_x;
+  int16_t stick_left_y;
+  int16_t stick_right_x;
+  int16_t stick_right_y;
 };
 #pragma pack(pop)
 
 static_assert(sizeof(Xbox360ButtonData) == 18, "xbox button data wrong size");
 static_assert(sizeof(XboxOneButtonData) == 14, "xbox button data wrong size");
 
 // From MSDN:
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ee417001(v=vs.85).aspx#dead_zone
-const int16 kLeftThumbDeadzone = 7849;
-const int16 kRightThumbDeadzone = 8689;
-const uint8 kXbox360TriggerDeadzone = 30;
-const uint16 kXboxOneTriggerMax = 1023;
-const uint16 kXboxOneTriggerDeadzone = 120;
+const int16_t kLeftThumbDeadzone = 7849;
+const int16_t kRightThumbDeadzone = 8689;
+const uint8_t kXbox360TriggerDeadzone = 30;
+const uint16_t kXboxOneTriggerMax = 1023;
+const uint16_t kXboxOneTriggerDeadzone = 120;
 
-void NormalizeAxis(int16 x,
-                       int16 y,
-                       int16 deadzone,
-                       float* x_out,
-                       float* y_out) {
+void NormalizeAxis(int16_t x,
+                   int16_t y,
+                   int16_t deadzone,
+                   float* x_out,
+                   float* y_out) {
   float x_val = x;
   float y_val = y;
 
   // Determine how far the stick is pushed.
   float real_magnitude = std::sqrt(x_val * x_val + y_val * y_val);
 
   // Check if the controller is outside a circular dead zone.
   if (real_magnitude > deadzone) {
     // Clip the magnitude at its expected maximum value.
     float magnitude = std::min(32767.0f, real_magnitude);
 
     // Adjust magnitude relative to the end of the dead zone.
     magnitude -= deadzone;
 
     // Normalize the magnitude with respect to its expected range giving a
     // magnitude value of 0.0 to 1.0
     float ratio = (magnitude / (32767 - deadzone)) / real_magnitude;
 
     // Y is negated because xbox controllers have an opposite sign from
     // the 'standard controller' recommendations.
     *x_out = x_val * ratio;
     *y_out = -y_val * ratio;
   } else {
     // If the controller is in the deadzone zero out the magnitude.
     *x_out = *y_out = 0.0f;
   }
 }
 
-float NormalizeTrigger(uint8 value) {
-  return value < kXbox360TriggerDeadzone ? 0 :
-      static_cast<float>(value - kXbox360TriggerDeadzone) /
-          (std::numeric_limits<uint8>::max() - kXbox360TriggerDeadzone);
+float NormalizeTrigger(uint8_t value) {
+  return value < kXbox360TriggerDeadzone
+             ? 0
+             : static_cast<float>(value - kXbox360TriggerDeadzone) /
+                   (std::numeric_limits<uint8_t>::max() -
+                    kXbox360TriggerDeadzone);
 }
 
-float NormalizeXboxOneTrigger(uint16 value) {
+float NormalizeXboxOneTrigger(uint16_t value) {
   return value < kXboxOneTriggerDeadzone ? 0 :
       static_cast<float>(value - kXboxOneTriggerDeadzone) /
           (kXboxOneTriggerMax - kXboxOneTriggerDeadzone);
 }
 
 void NormalizeXbox360ButtonData(const Xbox360ButtonData& data,
     XboxController::Data* normalized_data) {
   normalized_data->buttons[0] = data.a;
   normalized_data->buttons[1] = data.b;
   normalized_data->buttons[2] = data.x;
@@ skipping 214 matching lines @@
 
   CFRunLoopSourceRef source_ref;
   kr = (*interface_)->CreateInterfaceAsyncEventSource(interface_, &source_ref);
   if (kr != KERN_SUCCESS || !source_ref)
     return false;
   source_.reset(source_ref);
   CFRunLoopAddSource(CFRunLoopGetCurrent(), source_, kCFRunLoopDefaultMode);
 
   // The interface should have two pipes. Pipe 1 with direction kUSBIn and pipe
   // 2 with direction kUSBOut. Both pipes should have type kUSBInterrupt.
-  uint8 num_endpoints;
+  uint8_t num_endpoints;
   kr = (*interface_)->GetNumEndpoints(interface_, &num_endpoints);
   if (kr != KERN_SUCCESS || num_endpoints < 2)
     return false;
 
   for (int i = 1; i <= 2; i++) {
-    uint8 direction;
-    uint8 number;
-    uint8 transfer_type;
-    uint16 max_packet_size;
-    uint8 interval;
+    uint8_t direction;
+    uint8_t number;
+    uint8_t transfer_type;
+    uint16_t max_packet_size;
+    uint8_t interval;
 
     kr = (*interface_)->GetPipeProperties(interface_,
                                           i,
                                           &direction,
                                           &number,
                                           &transfer_type,
                                           &max_packet_size,
                                           &interval);
     if (kr != KERN_SUCCESS || transfer_type != kUSBInterrupt) {
       return false;
     }
     if (i == read_endpoint_) {
       if (direction != kUSBIn)
         return false;
-      read_buffer_.reset(new uint8[max_packet_size]);
+      read_buffer_.reset(new uint8_t[max_packet_size]);
       read_buffer_size_ = max_packet_size;
       QueueRead();
     } else if (i == control_endpoint_) {
       if (direction != kUSBOut)
         return false;
       if (controller_type_ == XBOX_ONE_CONTROLLER)
         WriteXboxOneInit();
     }
   }
 
@@ skipping 77 matching lines @@
 }
 
 void XboxController::ProcessXbox360Packet(size_t length) {
   if (length < 2)
     return;
   DCHECK(length <= read_buffer_size_);
   if (length > read_buffer_size_) {
     IOError();
     return;
   }
-  uint8* buffer = read_buffer_.get();
+  uint8_t* buffer = read_buffer_.get();
 
   if (buffer[1] != length)
     // Length in packet doesn't match length reported by USB.
     return;
 
-  uint8 type = buffer[0];
+  uint8_t type = buffer[0];
   buffer += 2;
   length -= 2;
   switch (type) {
     case STATUS_MESSAGE_BUTTONS: {
       if (length != sizeof(Xbox360ButtonData))
         return;
       Xbox360ButtonData* data = reinterpret_cast<Xbox360ButtonData*>(buffer);
       Data normalized_data;
       NormalizeXbox360ButtonData(*data, &normalized_data);
       delegate_->XboxControllerGotData(this, normalized_data);
@@ skipping 14 matching lines @@
 }
 
 void XboxController::ProcessXboxOnePacket(size_t length) {
   if (length < 2)
     return;
   DCHECK(length <= read_buffer_size_);
   if (length > read_buffer_size_) {
     IOError();
     return;
   }
-  uint8* buffer = read_buffer_.get();
+  uint8_t* buffer = read_buffer_.get();
 
-  uint8 type = buffer[0];
+  uint8_t type = buffer[0];
   buffer += 4;
   length -= 4;
   switch (type) {
     case XBOX_ONE_STATUS_MESSAGE_BUTTONS: {
       if (length != sizeof(XboxOneButtonData))
         return;
       XboxOneButtonData* data = reinterpret_cast<XboxOneButtonData*>(buffer);
       Data normalized_data;
       NormalizeXboxOneButtonData(*data, &normalized_data);
       delegate_->XboxControllerGotData(this, normalized_data);
@@ skipping 198 matching lines @@
   controllers_.insert(controller);
   delegate_->XboxDeviceAdd(controller);
 }
 
 void XboxDataFetcher::RemoveController(XboxController* controller) {
   delegate_->XboxDeviceRemove(controller);
   controllers_.erase(controller);
   delete controller;
 }
 
-void XboxDataFetcher::RemoveControllerByLocationID(uint32 location_id) {
+void XboxDataFetcher::RemoveControllerByLocationID(uint32_t location_id) {
   XboxController* controller = NULL;
   for (std::set<XboxController*>::iterator i = controllers_.begin();
        i != controllers_.end();
        ++i) {
     if ((*i)->location_id() == location_id) {
       controller = *i;
       break;
     }
   }
   if (controller)
     RemoveController(controller);
 }
 
 void XboxDataFetcher::XboxControllerGotData(XboxController* controller,
                                             const XboxController::Data& data) {
   delegate_->XboxValueChanged(controller, data);
 }
 
 void XboxDataFetcher::XboxControllerError(XboxController* controller) {
   RemoveController(controller);
 }