Replace usage of basictypes.h with a combination of stdint.h and base/macros.h.

components/component_updater/component_unpacker.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/component_updater/component_unpacker.h"
 
+#include <stdint.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
     if (len < sizeof(header))
       return;
 
     crx_file::CrxFile::Error error;
     scoped_ptr<crx_file::CrxFile> crx(
         crx_file::CrxFile::Parse(header, &error));
     if (!crx.get())
       return;
     is_delta_ = crx_file::CrxFile::HeaderIsDelta(header);
 
-    std::vector<uint8> key(header.key_size);
-    len = fread(&key[0], sizeof(uint8), header.key_size, crx_file);
+    std::vector<uint8_t> key(header.key_size);
+    len = fread(&key[0], sizeof(uint8_t), header.key_size, crx_file);
     if (len < header.key_size)
       return;
 
-    std::vector<uint8> signature(header.signature_size);
-    len = fread(&signature[0], sizeof(uint8), header.signature_size, crx_file);
+    std::vector<uint8_t> signature(header.signature_size);
+    len =
+        fread(&signature[0], sizeof(uint8_t), header.signature_size, crx_file);
     if (len < header.signature_size)
       return;
 
     crypto::SignatureVerifier verifier;
     if (!verifier.VerifyInit(crx_file::kSignatureAlgorithm,
                              base::checked_cast<int>(
                                  sizeof(crx_file::kSignatureAlgorithm)),
                              &signature[0],
                              base::checked_cast<int>(signature.size()),
                              &key[0],
                              base::checked_cast<int>(key.size()))) {
       // Signature verification initialization failed. This is most likely
       // caused by a public key in the wrong format (should encode algorithm).
       return;
     }
 
     const size_t kBufSize = 8 * 1024;
-    scoped_ptr<uint8[]> buf(new uint8[kBufSize]);
+    scoped_ptr<uint8_t[]> buf(new uint8_t[kBufSize]);
     while ((len = fread(buf.get(), 1, kBufSize, crx_file)) > 0)
       verifier.VerifyUpdate(buf.get(), base::checked_cast<int>(len));
 
     if (!verifier.VerifyFinal())
       return;
 
     public_key_.swap(key);
     valid_ = true;
   }
 
   bool valid() const { return valid_; }
 
   bool is_delta() const { return is_delta_; }
 
-  const std::vector<uint8>& public_key() const { return public_key_; }
+  const std::vector<uint8_t>& public_key() const { return public_key_; }
 
  private:
   bool valid_;
   bool is_delta_;
-  std::vector<uint8> public_key_;
+  std::vector<uint8_t> public_key_;
 };
 
 }  // namespace
 
 ComponentUnpacker::ComponentUnpacker(
-    const std::vector<uint8>& pk_hash,
+    const std::vector<uint8_t>& pk_hash,
     const base::FilePath& path,
     const std::string& fingerprint,
     ComponentInstaller* installer,
     scoped_refptr<OutOfProcessPatcher> out_of_process_patcher,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : pk_hash_(pk_hash),
       path_(path),
       is_delta_(false),
       fingerprint_(fingerprint),
       installer_(installer),
@@ skipping 50 matching lines @@
   file.reset();
   if (!validator.valid()) {
     error_ = kInvalidFile;
     return false;
   }
   is_delta_ = validator.is_delta();
 
   // File is valid and the digital signature matches. Now make sure
   // the public key hash matches the expected hash. If they do we fully
   // trust this CRX.
-  uint8 hash[32] = {};
+  uint8_t hash[32] = {};
   scoped_ptr<SecureHash> sha256(SecureHash::Create(SecureHash::SHA256));
   sha256->Update(&(validator.public_key()[0]), validator.public_key().size());
   sha256->Finish(hash, arraysize(hash));
 
   if (!std::equal(pk_hash_.begin(), pk_hash_.end(), hash)) {
     VLOG(1) << "Hash mismatch: " << path_.value();
     error_ = kInvalidId;
     return false;
   }
   VLOG(1) << "Verification successful: " << path_.value();
@@ skipping 92 matching lines @@
     base::DeleteFile(unpack_diff_path_, true);
   if (!unpack_path_.empty())
     base::DeleteFile(unpack_path_, true);
   callback_.Run(error_, extended_error_);
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
 }
 
 }  // namespace component_updater