Remove kuint8max.

sync/internal_api/public/base/unique_position.cc

 // 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.
 
 #include "sync/internal_api/public/base/unique_position.h"
 
-#include "base/basictypes.h"
+#include <limits>
+
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "sync/protocol/unique_position.pb.h"
 #include "third_party/zlib/zlib.h"
 
 namespace syncer {
 
 const size_t UniquePosition::kSuffixLength = 28;
@@ skipping 59 matching lines @@
           << " did not match specified length " << proto.uncompressed_length();
       return UniquePosition::CreateInvalid();
     }
     return UniquePosition(Compress(un_gzipped));
   } else {
     return UniquePosition::CreateInvalid();
   }
 }
 
 // static.
-UniquePosition UniquePosition::FromInt64(
-    int64 x, const std::string& suffix) {
-  uint64 y = static_cast<uint64>(x);
+UniquePosition UniquePosition::FromInt64(int64_t x, const std::string& suffix) {
+  uint64_t y = static_cast<uint64_t>(x);
   y ^= 0x8000000000000000ULL; // Make it non-negative.
   std::string bytes(8, 0);
   for (int i = 7; i >= 0; --i) {
-    bytes[i] = static_cast<uint8>(y);
+    bytes[i] = static_cast<uint8_t>(y);
     y >>= 8;
   }
   return UniquePosition(bytes + suffix, suffix);
 }
 
 // static.
 UniquePosition UniquePosition::InitialPosition(
     const std::string& suffix) {
   DCHECK(IsValidSuffix(suffix));
   return UniquePosition(suffix, suffix);
@@ skipping 65 matching lines @@
   // obsolete for a long time.  See the proto definition for details.
 }
 
 void UniquePosition::SerializeToString(std::string* blob) const {
   DCHECK(blob);
   sync_pb::UniquePosition proto;
   ToProto(&proto);
   proto.SerializeToString(blob);
 }
 
-int64 UniquePosition::ToInt64() const {
-  uint64 y = 0;
+int64_t UniquePosition::ToInt64() const {
+  uint64_t y = 0;
   const std::string& s = Uncompress(compressed_);
-  size_t l = sizeof(int64);
+  size_t l = sizeof(int64_t);
   if (s.length() < l) {
     NOTREACHED();
     l = s.length();
   }
   for (size_t i = 0; i < l; ++i) {
-    const uint8 byte = s[l - i - 1];
-    y |= static_cast<uint64>(byte) << (i * 8);
+    const uint8_t byte = s[l - i - 1];
+    y |= static_cast<uint64_t>(byte) << (i * 8);
   }
   y ^= 0x8000000000000000ULL;
   // This is technically implementation-defined if y > INT64_MAX, so
   // we're assuming that we're on a twos-complement machine.
-  return static_cast<int64>(y);
+  return static_cast<int64_t>(y);
 }
 
 bool UniquePosition::IsValid() const {
   return is_valid_;
 }
 
 std::string UniquePosition::ToDebugString() const {
   const std::string bytes = Uncompress(compressed_);
   if (bytes.empty())
     return std::string("INVALID[]");
@@ skipping 35 matching lines @@
     // Prepend zeroes so the result has as many zero digits as |reference|.
     return std::string(ref_zeroes - suffix_zeroes, '\0');
   } else if (suffix_zeroes > 1) {
     // Prepend zeroes so the result has one more zero digit than |reference|.
     // We could also take the "else" branch below, but taking this branch will
     // give us a smaller result.
     return std::string(ref_zeroes - suffix_zeroes + 1, '\0');
   } else {
     // Prepend zeroes to match those in the |reference|, then something smaller
     // than the first non-zero digit in |reference|.
-    char lt_digit = static_cast<uint8>(reference[ref_zeroes])/2;
+    char lt_digit = static_cast<uint8_t>(reference[ref_zeroes]) / 2;
     return std::string(ref_zeroes, '\0') + lt_digit;
   }
 }
 
 // static
 std::string UniquePosition::FindGreaterWithSuffix(
     const std::string& reference,
     const std::string& suffix) {
-  size_t ref_FFs = reference.find_first_not_of(kuint8max);
-  size_t suffix_FFs = suffix.find_first_not_of(kuint8max);
+  size_t ref_FFs =
+      reference.find_first_not_of(std::numeric_limits<uint8_t>::max());
+  size_t suffix_FFs =
+      suffix.find_first_not_of(std::numeric_limits<uint8_t>::max());
 
   if (ref_FFs == std::string::npos) {
     ref_FFs = reference.length();
   }
   if (suffix_FFs == std::string::npos) {
     suffix_FFs = suffix.length();
   }
 
   if (suffix_FFs > ref_FFs) {
     // Implies suffix > reference.
     return std::string();
   }
 
   if (suffix.substr(suffix_FFs) > reference.substr(ref_FFs)) {
     // Prepend FF digits to match those in |reference|.
-    return std::string(ref_FFs - suffix_FFs, kuint8max);
+    return std::string(ref_FFs - suffix_FFs,
+                       std::numeric_limits<uint8_t>::max());
   } else if (suffix_FFs > 1) {
     // Prepend enough leading FF digits so result has one more of them than
     // |reference| does.  We could also take the "else" branch below, but this
     // gives us a smaller result.
-    return std::string(ref_FFs - suffix_FFs + 1, kuint8max);
+    return std::string(ref_FFs - suffix_FFs + 1,
+                       std::numeric_limits<uint8_t>::max());
   } else {
     // Prepend FF digits to match those in |reference|, then something larger
     // than the first non-FF digit in |reference|.
-    char gt_digit = static_cast<uint8>(reference[ref_FFs]) +
-        (kuint8max - static_cast<uint8>(reference[ref_FFs]) + 1) / 2;
-    return std::string(ref_FFs, kuint8max) + gt_digit;
+    char gt_digit = static_cast<uint8_t>(reference[ref_FFs]) +
+                    (std::numeric_limits<uint8_t>::max() -
+                     static_cast<uint8_t>(reference[ref_FFs]) + 1) /
+                        2;
+    return std::string(ref_FFs, std::numeric_limits<uint8_t>::max()) + gt_digit;
   }
 }
 
 // static
 std::string UniquePosition::FindBetweenWithSuffix(
     const std::string& before,
     const std::string& after,
     const std::string& suffix) {
   DCHECK(IsValidSuffix(suffix));
   DCHECK_NE(before, after);
   DCHECK_LT(before, after);
 
   std::string mid;
 
   // Sometimes our suffix puts us where we want to be.
   if (before < suffix && suffix < after) {
     return std::string();
   }
 
   size_t i = 0;
   for ( ; i < std::min(before.length(), after.length()); ++i) {
-    uint8 a_digit = before[i];
-    uint8 b_digit = after[i];
+    uint8_t a_digit = before[i];
+    uint8_t b_digit = after[i];
 
     if (b_digit - a_digit >= 2) {
       mid.push_back(a_digit + (b_digit - a_digit)/2);
       return mid;
     } else if (a_digit == b_digit) {
       mid.push_back(a_digit);
 
       // Both strings are equal so far.  Will appending the suffix at this point
       // give us the comparison we're looking for?
       if (before.substr(i+1) < suffix && suffix < after.substr(i+1)) {
@@ skipping 136 matching lines @@
 //    The key insight is that the comparison value of a repeated character block
 //    depends on the value of the character that follows it.  If the character
 //    follows the repeated character has a value greater than the repeated
 //    character itself, then a shorter run length should translate to a higher
 //    comparison value.  Therefore, we encode its count using the low encoding.
 //    Similarly, if the following character is lower, we use the high encoding.
 
 namespace {
 
 // Appends an encoded run length to |output_str|.
-static void WriteEncodedRunLength(uint32 length,
+static void WriteEncodedRunLength(uint32_t length,
                                   bool high_encoding,
                                   std::string* output_str) {
   CHECK_GE(length, 4U);
   CHECK_LT(length, 0x80000000);
 
   // Step 1: Invert the count, if necessary, to account for the following digit.
-  uint32 encoded_length;
+  uint32_t encoded_length;
   if (high_encoding) {
     encoded_length = 0xffffffff - length;
   } else {
     encoded_length = length;
   }
 
   // Step 2: Write it as big-endian so it compares correctly with memcmp(3).
   output_str->append(1, 0xff & (encoded_length >> 24U));
   output_str->append(1, 0xff & (encoded_length >> 16U));
   output_str->append(1, 0xff & (encoded_length >> 8U));
   output_str->append(1, 0xff & (encoded_length >> 0U));
 }
 
 // Reads an encoded run length for |str| at position |i|.
-static uint32 ReadEncodedRunLength(const std::string& str, size_t i) {
+static uint32_t ReadEncodedRunLength(const std::string& str, size_t i) {
   DCHECK_LE(i + 4, str.length());
 
   // Step 1: Extract the big-endian count.
-  uint32 encoded_length =
-      ((uint8)(str[i+3]) << 0)  |
-      ((uint8)(str[i+2]) << 8)  |
-      ((uint8)(str[i+1]) << 16) |
-      ((uint8)(str[i+0]) << 24);
+  uint32_t encoded_length =
+      ((uint8_t)(str[i + 3]) << 0) | ((uint8_t)(str[i + 2]) << 8) |
+      ((uint8_t)(str[i + 1]) << 16) | ((uint8_t)(str[i + 0]) << 24);
 
   // Step 2: If this was an inverted count, un-invert it.
-  uint32 length;
+  uint32_t length;
   if (encoded_length & 0x80000000) {
     length = 0xffffffff - encoded_length;
   } else {
     length = encoded_length;
   }
 
   return length;
 }
 
 // A series of four identical chars at the beginning of a block indicates
@@ skipping 41 matching lines @@
       const size_t runs_until = str.find_first_not_of(rep_digit, i+4);
 
       // Handle the 'runs until end' special case specially.
       size_t run_length;
       bool encode_high;  // True if the next byte is greater than |rep_digit|.
       if (runs_until == std::string::npos) {
         run_length = str.length() - i;
         encode_high = false;
       } else {
         run_length = runs_until - i;
-        encode_high = static_cast<uint8>(str[runs_until]) >
-            static_cast<uint8>(rep_digit);
+        encode_high = static_cast<uint8_t>(str[runs_until]) >
+                      static_cast<uint8_t>(rep_digit);
       }
-      DCHECK_LT(run_length, static_cast<size_t>(kint32max))
+      DCHECK_LT(run_length,
+                static_cast<size_t>(std::numeric_limits<int32_t>::max()))
           << "This implementation can't encode run-lengths greater than 2^31.";
 
       WriteEncodedRunLength(run_length, encode_high, &output);
       i += run_length;  // Jump forward by the size of the run length.
     } else {
       // Output up to eight bytes without any encoding.
       const size_t len = std::min(static_cast<size_t>(8), str.length() - i);
       output.append(str, i, len);
       i += len;  // Jump forward by the amount of input consumed (usually 8).
     }
   }
 
   return output;
 }
 
 // static
 // Uncompresses strings that were compresed with UniquePosition::Compress.
 std::string UniquePosition::Uncompress(const std::string& str) {
   std::string output;
   size_t i = 0;
   // Iterate through the compressed string one block at a time.
   for (i = 0; i + 8 <= str.length(); i += 8) {
     if (IsRepeatedCharPrefix(str, i)) {
       // Found a repeated character block.  Expand it.
       const char rep_digit = str[i];
-      uint32 length = ReadEncodedRunLength(str, i+4);
+      uint32_t length = ReadEncodedRunLength(str, i + 4);
       output.append(length, rep_digit);
     } else {
       // Found a regular block.  Copy it.
       output.append(str, i, 8);
     }
   }
   // Copy the remaining bytes that were too small to form a block.
   output.append(str, i, std::string::npos);
   return output;
 }
 
 bool UniquePosition::IsValidCompressed(const std::string& str) {
   for (size_t i = 0; i + 8 <= str.length(); i += 8) {
     if (IsRepeatedCharPrefix(str, i)) {
-      uint32 count = ReadEncodedRunLength(str, i+4);
+      uint32_t count = ReadEncodedRunLength(str, i + 4);
       if (count < 4) {
         // A repeated character block should at least represent the four
         // characters that started it.
         return false;
       }
       if (str[i] == str[i+4]) {
         // Does the next digit after a count match the repeated character?  Then
         // this is not the highest possible count.
         return false;
       }
     }
   }
   // We don't bother looking for the existence or checking the validity of
   // any partial blocks.  There's no way they could be invalid anyway.
   return true;
 }
 
 }  // namespace syncer