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

components/component_updater/component_patcher_operation.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_patcher_operation.h"
 
+#include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/component_updater/component_patcher.h"
 #include "components/component_updater/component_updater_service.h"
 #include "courgette/courgette.h"
@@ skipping 83 matching lines @@
   if (error == ComponentUnpacker::kNone)
     error = CheckHash();
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(callback_, error, extended_error));
   callback_.Reset();
 }
 
 // Uses the hash as a checksum to confirm that the file now residing in the
 // output directory probably has the contents it should.
 ComponentUnpacker::Error DeltaUpdateOp::CheckHash() {
-  std::vector<uint8> expected_hash;
+  std::vector<uint8_t> expected_hash;
   if (!base::HexStringToBytes(output_sha256_, &expected_hash) ||
       expected_hash.size() != crypto::kSHA256Length)
     return ComponentUnpacker::kDeltaVerificationFailure;
 
   base::MemoryMappedFile output_file_mmapped;
   if (!output_file_mmapped.Initialize(output_abs_path_))
     return ComponentUnpacker::kDeltaVerificationFailure;
 
-  uint8 actual_hash[crypto::kSHA256Length] = {0};
+  uint8_t actual_hash[crypto::kSHA256Length] = {0};
   const scoped_ptr<SecureHash> hasher(SecureHash::Create(SecureHash::SHA256));
   hasher->Update(output_file_mmapped.data(), output_file_mmapped.length());
   hasher->Finish(actual_hash, sizeof(actual_hash));
   if (memcmp(actual_hash, &expected_hash[0], sizeof(actual_hash)))
     return ComponentUnpacker::kDeltaVerificationFailure;
 
   return ComponentUnpacker::kNone;
 }
 
 scoped_refptr<base::SequencedTaskRunner> DeltaUpdateOp::GetTaskRunner() {
@@ skipping 126 matching lines @@
     } else {
       callback.Run(ComponentUnpacker::kDeltaOperationFailure,
                    result + kCourgetteErrorOffset);
     }
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace component_updater