Switch to standard integer types in sync/.

sync/internal_api/public/base/ordinal.h

 // Copyright (c) 2012 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.
 
 #ifndef SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_
 #define SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <cstddef>
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 
 namespace syncer {
 
 // An Ordinal<T> is an object that can be used for ordering. The
 // Ordinal<T> class has an unbounded dense strict total order, which
 // mean for any Ordinal<T>s a, b and c:
 //
 //  - a < b and b < c implies a < c (transitivity);
 //  - exactly one of a < b, b < a and a = b holds (trichotomy);
 //  - if a < b, there is a Ordinal<T> x such that a < x < b (density);
 //  - there are Ordinals<T> x and y such that x < a < y (unboundedness).
 //
 // This means that when Ordinal<T> is used for sorting a list, if any
 // item changes its position in the list, only its Ordinal<T> value
 // has to change to represent the new order, and all the other values
 // can stay the same.
 //
 // An Ordinal<T> is internally represented as an array of bytes, so it
 // can be serialized to and deserialized from disk.
 //
 // The Traits class should look like the following:
 //
 //   // Don't forget to #include "base/basictypes.h".
 //   struct MyOrdinalTraits {
 //     // There must be at least two distinct values greater than kZeroDigit
 //     // and less than kMaxDigit.
-//     static const uint8 kZeroDigit = '0';
-//     static const uint8 kMaxDigit = '9';
+//     static const uint8_t kZeroDigit = '0';
+//     static const uint8_t kMaxDigit = '9';
 //     // kMinLength must be positive.
 //     static const size_t kMinLength = 1;
 //   };
 //
 // An Ordinal<T> is valid iff its corresponding string has at least
 // kMinLength characters, does not contain any characters less than
 // kZeroDigit or greater than kMaxDigit, is not all zero digits, and
 // does not have any unnecessary trailing zero digits.
 //
 // Note that even if the native char type is signed, strings still
@@ skipping 72 matching lines @@
   Ordinal CreateAfter() const;
 
   // Returns the string of bytes representing the Ordinal.  It is
   // guaranteed that an Ordinal constructed from the returned string
   // will be valid.
   std::string ToInternalValue() const;
 
   // Use of copy constructor and default assignment for this class is allowed.
 
   // Constants for Ordinal digits.
-  static const uint8 kZeroDigit = Traits::kZeroDigit;
-  static const uint8 kMaxDigit = Traits::kMaxDigit;
+  static const uint8_t kZeroDigit = Traits::kZeroDigit;
+  static const uint8_t kMaxDigit = Traits::kMaxDigit;
   static const size_t kMinLength = Traits::kMinLength;
-  static const uint8 kOneDigit = kZeroDigit + 1;
-  static const uint8 kMidDigit = kOneDigit + (kMaxDigit - kOneDigit) / 2;
+  static const uint8_t kOneDigit = kZeroDigit + 1;
+  static const uint8_t kMidDigit = kOneDigit + (kMaxDigit - kOneDigit) / 2;
   static const unsigned int kMidDigitValue = kMidDigit - kZeroDigit;
   static const unsigned int kMaxDigitValue = kMaxDigit - kZeroDigit;
   static const unsigned int kRadix = kMaxDigitValue + 1;
 
   static_assert(kOneDigit > kZeroDigit, "incorrect ordinal one digit");
   static_assert(kMidDigit > kOneDigit, "incorrect ordinal mid digit");
   static_assert(kMaxDigit > kMidDigit, "incorrect ordinal max digit");
   static_assert(kMinLength > 0, "incorrect ordinal min length");
   static_assert(kMidDigitValue > 1, "incorrect ordinal mid digit");
   static_assert(kMaxDigitValue > kMidDigitValue, "incorrect ordinal max digit");
   static_assert(kRadix == kMaxDigitValue + 1, "incorrect ordinal radix");
 
  private:
   // Returns true iff the given byte string satisfies the criteria for
   // a valid Ordinal.
   static bool IsValidOrdinalBytes(const std::string& bytes);
 
   // Returns the length that bytes.substr(0, length) would be with
   // trailing zero digits removed.
   static size_t GetLengthWithoutTrailingZeroDigits(
       const std::string& bytes,
       size_t length);
 
   // Returns the digit at position i, padding with zero digits if
   // required.
-  static uint8 GetDigit(const std::string& bytes, size_t i);
+  static uint8_t GetDigit(const std::string& bytes, size_t i);
 
   // Returns the digit value at position i, padding with 0 if required.
   static int GetDigitValue(const std::string& bytes, size_t i);
 
   // Adds the given value to |bytes| at position i, carrying when
   // necessary.  Returns the left-most carry.
   static int AddDigitValue(std::string* bytes, size_t i, int digit_value);
 
   // Returns the proper length |bytes| should be resized to, i.e. the
   // smallest length such that |bytes| is still greater than
@@ skipping 14 matching lines @@
                                               const Ordinal<Traits>& end);
 
   // The internal byte string representation of the Ordinal.  Never
   // changes after construction except for assignment.
   std::string bytes_;
 
   // A cache of the result of IsValidOrdinalBytes(bytes_).
   bool is_valid_;
 };
 
-template <typename Traits> const uint8 Ordinal<Traits>::kZeroDigit;
-template <typename Traits> const uint8 Ordinal<Traits>::kMaxDigit;
+template <typename Traits>
+const uint8_t Ordinal<Traits>::kZeroDigit;
+template <typename Traits>
+const uint8_t Ordinal<Traits>::kMaxDigit;
 template <typename Traits> const size_t Ordinal<Traits>::kMinLength;
-template <typename Traits> const uint8 Ordinal<Traits>::kOneDigit;
-template <typename Traits> const uint8 Ordinal<Traits>::kMidDigit;
+template <typename Traits>
+const uint8_t Ordinal<Traits>::kOneDigit;
+template <typename Traits>
+const uint8_t Ordinal<Traits>::kMidDigit;
 template <typename Traits> const unsigned int Ordinal<Traits>::kMidDigitValue;
 template <typename Traits> const unsigned int Ordinal<Traits>::kMaxDigitValue;
 template <typename Traits> const unsigned int Ordinal<Traits>::kRadix;
 
 template <typename Traits>
 Ordinal<Traits>::LessThanFn::LessThanFn() {}
 
 template <typename Traits>
 bool Ordinal<Traits>::LessThanFn::operator()(const Ordinal<Traits>& lhs,
                                              const Ordinal<Traits>& rhs) const {
@@ skipping 126 matching lines @@
 }
 
 template <typename Traits>
 bool Ordinal<Traits>::IsValidOrdinalBytes(const std::string& bytes) {
   const size_t length = bytes.length();
   if (length < kMinLength)
     return false;
 
   bool found_non_zero = false;
   for (size_t i = 0; i < length; ++i) {
-    const uint8 byte = bytes[i];
+    const uint8_t byte = bytes[i];
     if (byte < kZeroDigit || byte > kMaxDigit)
       return false;
     if (byte > kZeroDigit)
       found_non_zero = true;
   }
   if (!found_non_zero)
     return false;
 
   if (length > kMinLength) {
-    const uint8 last_byte = bytes[length - 1];
+    const uint8_t last_byte = bytes[length - 1];
     if (last_byte == kZeroDigit)
       return false;
   }
 
   return true;
 }
 
 template <typename Traits>
 size_t Ordinal<Traits>::GetLengthWithoutTrailingZeroDigits(
     const std::string& bytes, size_t length) {
   DCHECK(!bytes.empty());
   DCHECK_GT(length, 0U);
 
   size_t end_position =
       bytes.find_last_not_of(static_cast<char>(kZeroDigit), length - 1);
 
   // If no non kZeroDigit is found then the string is a string of all zeros
   // digits so we return 0 as the correct length.
   if (end_position == std::string::npos)
     return 0;
 
   return end_position + 1;
 }
 
 template <typename Traits>
-uint8 Ordinal<Traits>::GetDigit(const std::string& bytes, size_t i) {
+uint8_t Ordinal<Traits>::GetDigit(const std::string& bytes, size_t i) {
   return (i < bytes.length()) ? bytes[i] : kZeroDigit;
 }
 
 template <typename Traits>
 int Ordinal<Traits>::GetDigitValue(const std::string& bytes, size_t i) {
   return GetDigit(bytes, i) - kZeroDigit;
 }
 
 template <typename Traits>
 int Ordinal<Traits>::AddDigitValue(std::string* bytes,
@@ skipping 77 matching lines @@
   DCHECK_LT(midpoint, end_bytes);
 
   Ordinal<Traits> midpoint_ordinal(midpoint);
   DCHECK(midpoint_ordinal.IsValid());
   return midpoint_ordinal;
 }
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_BASE_ORDINAL_H_