Switch to standard integer types in components/, part 4 of 4.

components/variations/variations_seed_store.cc

 // Copyright 2014 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 "components/variations/variations_seed_store.h"
 
+#include <stdint.h>
+
 #include "base/base64.h"
+#include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
+#include "build/build_config.h"
 #include "components/compression/compression_utils.h"
 #include "components/variations/pref_names.h"
 #include "components/variations/proto/variations_seed.pb.h"
 #include "crypto/signature_verifier.h"
 #include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
 
 #if defined(OS_ANDROID)
 #include "components/variations/android/variations_seed_bridge.h"
 #endif  // OS_ANDROID
 
@@ skipping 16 matching lines @@
 //   ecdsa-with-SHA256 OBJECT IDENTIFIER ::= { iso(1) member-body(2)
 //        us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) 2 }
 //   ...
 //   When the ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-SHA384, or
 //   ecdsa-with-SHA512 algorithm identifier appears in the algorithm field
 //   as an AlgorithmIdentifier, the encoding MUST omit the parameters
 //   field.  That is, the AlgorithmIdentifier SHALL be a SEQUENCE of one
 //   component, the OID ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-
 //   SHA384, or ecdsa-with-SHA512.
 // See also RFC 5480, Appendix A.
-const uint8 kECDSAWithSHA256AlgorithmID[] = {
-  0x30, 0x0a,
-    0x06, 0x08,
-      0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
+const uint8_t kECDSAWithSHA256AlgorithmID[] = {
+    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
 };
 
 // The ECDSA public key of the variations server for verifying variations seed
 // signatures.
 const uint8_t kPublicKey[] = {
   0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01,
   0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00,
   0x04, 0x51, 0x7c, 0x31, 0x4b, 0x50, 0x42, 0xdd, 0x59, 0xda, 0x0b, 0xfa, 0x43,
   0x44, 0x33, 0x7c, 0x5f, 0xa1, 0x0b, 0xd5, 0x82, 0xf6, 0xac, 0x04, 0x19, 0x72,
   0x6c, 0x40, 0xd4, 0x3e, 0x56, 0xe2, 0xa0, 0x80, 0xa0, 0x41, 0xb3, 0x23, 0x7b,
@@ skipping 224 matching lines @@
     RecordSeedStoreHistogram(VARIATIONS_SEED_STORE_FAILED_DELTA_STORE);
   }
   return result;
 }
 
 void VariationsSeedStore::UpdateSeedDateAndLogDayChange(
     const base::Time& server_date_fetched) {
   VariationsSeedDateChangeState date_change = SEED_DATE_NO_OLD_DATE;
 
   if (local_state_->HasPrefPath(prefs::kVariationsSeedDate)) {
-    const int64 stored_date_value =
+    const int64_t stored_date_value =
         local_state_->GetInt64(prefs::kVariationsSeedDate);
     const base::Time stored_date =
         base::Time::FromInternalValue(stored_date_value);
 
     date_change = GetSeedDateChangeState(server_date_fetched, stored_date);
   }
 
   UMA_HISTOGRAM_ENUMERATION("Variations.SeedDateChange", date_change,
                             SEED_DATE_ENUM_SIZE);
 
@@ skipping 25 matching lines @@
   if (base64_seed_signature.empty())
     return VARIATIONS_SEED_SIGNATURE_MISSING;
 
   std::string signature;
   if (!base::Base64Decode(base64_seed_signature, &signature))
     return VARIATIONS_SEED_SIGNATURE_DECODE_FAILED;
 
   crypto::SignatureVerifier verifier;
   if (!verifier.VerifyInit(
           kECDSAWithSHA256AlgorithmID, sizeof(kECDSAWithSHA256AlgorithmID),
-          reinterpret_cast<const uint8*>(signature.data()), signature.size(),
+          reinterpret_cast<const uint8_t*>(signature.data()), signature.size(),
           kPublicKey, arraysize(kPublicKey))) {
     return VARIATIONS_SEED_SIGNATURE_INVALID_SIGNATURE;
   }
 
-  verifier.VerifyUpdate(reinterpret_cast<const uint8*>(seed_bytes.data()),
+  verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(seed_bytes.data()),
                         seed_bytes.size());
   if (verifier.VerifyFinal())
     return VARIATIONS_SEED_SIGNATURE_VALID;
   return VARIATIONS_SEED_SIGNATURE_INVALID_SEED;
 }
 
 void VariationsSeedStore::ClearPrefs() {
   local_state_->ClearPref(prefs::kVariationsCompressedSeed);
   local_state_->ClearPref(prefs::kVariationsSeed);
   local_state_->ClearPref(prefs::kVariationsSeedDate);
@@ skipping 135 matching lines @@
   return true;
 }
 
 // static
 bool VariationsSeedStore::ApplyDeltaPatch(const std::string& existing_data,
                                           const std::string& patch,
                                           std::string* output) {
   output->clear();
 
   google::protobuf::io::CodedInputStream in(
-      reinterpret_cast<const uint8*>(patch.data()), patch.length());
+      reinterpret_cast<const uint8_t*>(patch.data()), patch.length());
   // Temporary string declared outside the loop so it can be re-used between
   // different iterations (rather than allocating new ones).
   std::string temp;
 
-  const uint32 existing_data_size = static_cast<uint32>(existing_data.size());
+  const uint32_t existing_data_size =
+      static_cast<uint32_t>(existing_data.size());
   while (in.CurrentPosition() != static_cast<int>(patch.length())) {
-    uint32 value;
+    uint32_t value;
     if (!in.ReadVarint32(&value))
       return false;
 
     if (value != 0) {
       // A non-zero value indicates the number of bytes to copy from the patch
       // stream to the output.
 
       // No need to guard against bad data (i.e. very large |value|) because the
       // call below will fail if |value| is greater than the size of the patch.
       if (!in.ReadString(&temp, value))
         return false;
       output->append(temp);
     } else {
       // Otherwise, when it's zero, it indicates that it's followed by a pair of
       // numbers - |offset| and |length| that specify a range of data to copy
       // from |existing_data|.
-      uint32 offset;
-      uint32 length;
+      uint32_t offset;
+      uint32_t length;
       if (!in.ReadVarint32(&offset) || !in.ReadVarint32(&length))
         return false;
 
       // Check for |offset + length| being out of range and for overflow.
-      base::CheckedNumeric<uint32> end_offset(offset);
+      base::CheckedNumeric<uint32_t> end_offset(offset);
       end_offset += length;
       if (!end_offset.IsValid() || end_offset.ValueOrDie() > existing_data_size)
         return false;
       output->append(existing_data, offset, length);
     }
   }
   return true;
 }
 
 void VariationsSeedStore::ReportUnsupportedSeedFormatError() {
   RecordSeedStoreHistogram(
       VARIATIONS_SEED_STORE_FAILED_UNSUPPORTED_SEED_FORMAT);
 }
 
 }  // namespace variations