Switch to standard integer types in extensions/browser/.

extensions/browser/verified_contents.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 "extensions/browser/verified_contents.h"
 
+#include <stddef.h>
+
 #include "base/base64url.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/crx_file/id_util.h"
 #include "crypto/signature_verifier.h"
 #include "extensions/common/extension.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 
 namespace {
 
 // Note: this structure is an ASN.1 which encodes the algorithm used with its
 // parameters.  The signature algorithm is "RSA256" aka "RSASSA-PKCS-v1_5 using
 // SHA-256 hash algorithm". This is defined in PKCS #1 (RFC 3447).
 // It is encoding: { OID sha256WithRSAEncryption      PARAMETERS NULL }
-const uint8 kSignatureAlgorithm[15] = {0x30, 0x0d, 0x06, 0x09, 0x2a,
-                                       0x86, 0x48, 0x86, 0xf7, 0x0d,
-                                       0x01, 0x01, 0x0b, 0x05, 0x00};
+const uint8_t kSignatureAlgorithm[15] = {0x30, 0x0d, 0x06, 0x09, 0x2a,
+                                         0x86, 0x48, 0x86, 0xf7, 0x0d,
+                                         0x01, 0x01, 0x0b, 0x05, 0x00};
 
 const char kBlockSizeKey[] = "block_size";
 const char kContentHashesKey[] = "content_hashes";
 const char kDescriptionKey[] = "description";
 const char kFilesKey[] = "files";
 const char kFormatKey[] = "format";
 const char kHashBlockSizeKey[] = "hash_block_size";
 const char kHeaderKidKey[] = "header.kid";
 const char kItemIdKey[] = "item_id";
 const char kItemVersionKey[] = "item_version";
@@ skipping 21 matching lines @@
     if (dictionary->GetString(key, &found_value) && found_value == value)
       return dictionary;
   }
   return NULL;
 }
 
 }  // namespace
 
 namespace extensions {
 
-VerifiedContents::VerifiedContents(const uint8* public_key, int public_key_size)
+VerifiedContents::VerifiedContents(const uint8_t* public_key,
+                                   int public_key_size)
     : public_key_(public_key),
       public_key_size_(public_key_size),
       valid_signature_(false),  // Guilty until proven innocent.
-      block_size_(0) {
-}
+      block_size_(0) {}
 
 VerifiedContents::~VerifiedContents() {
 }
 
 // The format of the payload json is:
 // {
 //   "item_id": "<extension id>",
 //   "item_version": "<extension version>",
 //   "content_hashes": [
 //     {
@@ skipping 213 matching lines @@
     return false;
 
   return true;
 }
 
 bool VerifiedContents::VerifySignature(const std::string& protected_value,
                                        const std::string& payload,
                                        const std::string& signature_bytes) {
   crypto::SignatureVerifier signature_verifier;
   if (!signature_verifier.VerifyInit(
-          kSignatureAlgorithm,
-          sizeof(kSignatureAlgorithm),
-          reinterpret_cast<const uint8*>(signature_bytes.data()),
-          signature_bytes.size(),
-          public_key_,
-          public_key_size_)) {
+          kSignatureAlgorithm, sizeof(kSignatureAlgorithm),
+          reinterpret_cast<const uint8_t*>(signature_bytes.data()),
+          signature_bytes.size(), public_key_, public_key_size_)) {
     VLOG(1) << "Could not verify signature - VerifyInit failure";
     return false;
   }
 
   signature_verifier.VerifyUpdate(
-      reinterpret_cast<const uint8*>(protected_value.data()),
+      reinterpret_cast<const uint8_t*>(protected_value.data()),
       protected_value.size());
 
   std::string dot(".");
-  signature_verifier.VerifyUpdate(reinterpret_cast<const uint8*>(dot.data()),
+  signature_verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(dot.data()),
                                   dot.size());
 
   signature_verifier.VerifyUpdate(
-      reinterpret_cast<const uint8*>(payload.data()), payload.size());
+      reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions