Switch to standard integer types in base/.

BUG=138542 TBR=mark@chromium.org NOPRESUBMIT=true Review URL: https://codereview.chromium.org/1538743002 Cr-Commit-Position: refs/heads/master@{#366910}
marcosholgado · Dec 26, 2015 · 9b6f429 · 9b6f429
1 parent 28523e2
commit 9b6f429
Show file tree

Hide file tree

Showing 296 changed files with 1,213 additions and 815 deletions.
diff --git a/DEPS b/DEPS
@@ -387,7 +387,7 @@ deps_os = {
 
     # For Linux and Chromium OS.
     'src/third_party/cros_system_api':
-     Var('chromium_git') + '/chromiumos/platform/system_api.git' + '@' + 'ed198c46f73e67d9a494c3c0623e3ba16e4da5e8',
+     Var('chromium_git') + '/chromiumos/platform/system_api.git' + '@' + 'd9ecb3bd87504815d4c58a6a8b9031deb2498d19',
 
     # Note that this is different from Android's freetype repo.
     'src/third_party/freetype2/src':

diff --git a/base/allocator/allocator_shim_win.cc b/base/allocator/allocator_shim_win.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <limits.h>
 #include <malloc.h>
 #include <new.h>
 #include <windows.h>
-
-#include "base/basictypes.h"
+#include <stddef.h>
 
 // This shim make it possible to perform additional checks on allocations
 // before passing them to the Heap functions.

diff --git a/base/allocator/unittest_utils.cc b/base/allocator/unittest_utils.cc
@@ -6,6 +6,7 @@
 // of other libraries
 
 #include <config.h>
+#include <stddef.h>
 
 inline int snprintf(char* buffer, size_t count, const char* format, ...) {
     int result;

diff --git a/base/at_exit.h b/base/at_exit.h
@@ -8,8 +8,8 @@
 #include <stack>
 
 #include "base/base_export.h"
-#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/synchronization/lock.h"
 
 namespace base {

diff --git a/base/atomic_sequence_num.h b/base/atomic_sequence_num.h
@@ -6,7 +6,7 @@
 #define BASE_ATOMIC_SEQUENCE_NUM_H_
 
 #include "base/atomicops.h"
-#include "base/basictypes.h"
+#include "base/macros.h"
 
 namespace base {
 

diff --git a/base/atomicops_internals_atomicword_compat.h b/base/atomicops_internals_atomicword_compat.h
@@ -7,7 +7,11 @@
 #ifndef BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
 #define BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
 
-// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
+#include <stdint.h>
+
+#include "build/build_config.h"
+
+// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32_t,
 // which in turn means int. On some LP32 platforms, intptr_t is an int, but
 // on others, it's a long. When AtomicWord and Atomic32 are based on different
 // fundamental types, their pointers are incompatible.

diff --git a/base/atomicops_internals_portable.h b/base/atomicops_internals_portable.h
@@ -34,6 +34,8 @@
 
 #include <atomic>
 
+#include "build/build_config.h"
+
 namespace base {
 namespace subtle {
 

diff --git a/base/atomicops_internals_x86_msvc.h b/base/atomicops_internals_x86_msvc.h
@@ -12,6 +12,7 @@
 #include <intrin.h>
 
 #include "base/macros.h"
+#include "build/build_config.h"
 
 #if defined(ARCH_CPU_64_BITS)
 // windows.h #defines this (only on x64). This causes problems because the

diff --git a/base/auto_reset.h b/base/auto_reset.h
@@ -5,7 +5,7 @@
 #ifndef BASE_AUTO_RESET_H_
 #define BASE_AUTO_RESET_H_
 
-#include "base/basictypes.h"
+#include "base/macros.h"
 
 // base::AutoReset<> is useful for setting a variable to a new value only within
 // a particular scope. An base::AutoReset<> object resets a variable to its

diff --git a/base/base64.cc b/base/base64.cc
@@ -4,6 +4,8 @@
 
 #include "base/base64.h"
 
+#include <stddef.h>
+
 #include "third_party/modp_b64/modp_b64.h"
 
 namespace base {

diff --git a/base/base64url.cc b/base/base64url.cc
@@ -4,7 +4,10 @@
 
 #include "base/base64url.h"
 
+#include <stddef.h>
+
 #include "base/base64.h"
+#include "base/macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_util.h"
 #include "third_party/modp_b64/modp_b64.h"

diff --git a/base/base64url.h b/base/base64url.h
@@ -9,6 +9,7 @@
 
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/strings/string_piece.h"
 
 namespace base {

diff --git a/base/base64url_unittest.cc b/base/base64url_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "base/base64url.h"
 
+#include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {

diff --git a/base/base_paths_mac.mm b/base/base_paths_mac.mm
@@ -8,6 +8,7 @@
 #include <dlfcn.h>
 #import <Foundation/Foundation.h>
 #include <mach-o/dyld.h>
+#include <stdint.h>
 
 #include "base/base_paths.h"
 #include "base/compiler_specific.h"

diff --git a/base/base_paths_posix.cc b/base/base_paths_posix.cc
@@ -7,6 +7,7 @@
 // Android).
 
 #include <limits.h>
+#include <stddef.h>
 
 #include <ostream>
 #include <string>

diff --git a/base/base_switches.cc b/base/base_switches.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/base_switches.h"
+#include "build/build_config.h"
 
 namespace switches {
 

diff --git a/base/big_endian.cc b/base/big_endian.cc
@@ -43,19 +43,19 @@ bool BigEndianReader::Read(T* value) {
   return true;
 }
 
-bool BigEndianReader::ReadU8(uint8* value) {
+bool BigEndianReader::ReadU8(uint8_t* value) {
   return Read(value);
 }
 
-bool BigEndianReader::ReadU16(uint16* value) {
+bool BigEndianReader::ReadU16(uint16_t* value) {
   return Read(value);
 }
 
-bool BigEndianReader::ReadU32(uint32* value) {
+bool BigEndianReader::ReadU32(uint32_t* value) {
   return Read(value);
 }
 
-bool BigEndianReader::ReadU64(uint64* value) {
+bool BigEndianReader::ReadU64(uint64_t* value) {
   return Read(value);
 }
 
@@ -86,19 +86,19 @@ bool BigEndianWriter::Write(T value) {
   return true;
 }
 
-bool BigEndianWriter::WriteU8(uint8 value) {
+bool BigEndianWriter::WriteU8(uint8_t value) {
   return Write(value);
 }
 
-bool BigEndianWriter::WriteU16(uint16 value) {
+bool BigEndianWriter::WriteU16(uint16_t value) {
   return Write(value);
 }
 
-bool BigEndianWriter::WriteU32(uint32 value) {
+bool BigEndianWriter::WriteU32(uint32_t value) {
   return Write(value);
 }
 
-bool BigEndianWriter::WriteU64(uint64 value) {
+bool BigEndianWriter::WriteU64(uint64_t value) {
   return Write(value);
 }
 

diff --git a/base/big_endian.h b/base/big_endian.h
@@ -5,8 +5,10 @@
 #ifndef BASE_BIG_ENDIAN_H_
 #define BASE_BIG_ENDIAN_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/base_export.h"
-#include "base/basictypes.h"
 #include "base/strings/string_piece.h"
 
 namespace base {
@@ -21,8 +23,8 @@ inline void ReadBigEndian(const char buf[], T* out) {
   *out = buf[0];
   for (size_t i = 1; i < sizeof(T); ++i) {
     *out <<= 8;
-    // Must cast to uint8 to avoid clobbering by sign extension.
-    *out |= static_cast<uint8>(buf[i]);
+    // Must cast to uint8_t to avoid clobbering by sign extension.
+    *out |= static_cast<uint8_t>(buf[i]);
   }
 }
 
@@ -37,13 +39,13 @@ inline void WriteBigEndian(char buf[], T val) {
 }
 
 // Specializations to make clang happy about the (dead code) shifts above.
-template<>
-inline void ReadBigEndian<uint8>(const char buf[], uint8* out) {
+template <>
+inline void ReadBigEndian<uint8_t>(const char buf[], uint8_t* out) {
   *out = buf[0];
 }
 
-template<>
-inline void WriteBigEndian<uint8>(char buf[], uint8 val) {
+template <>
+inline void WriteBigEndian<uint8_t>(char buf[], uint8_t val) {
   buf[0] = static_cast<char>(val);
 }
 
@@ -60,10 +62,10 @@ class BASE_EXPORT BigEndianReader {
   bool ReadBytes(void* out, size_t len);
   // Creates a StringPiece in |out| that points to the underlying buffer.
   bool ReadPiece(base::StringPiece* out, size_t len);
-  bool ReadU8(uint8* value);
-  bool ReadU16(uint16* value);
-  bool ReadU32(uint32* value);
-  bool ReadU64(uint64* value);
+  bool ReadU8(uint8_t* value);
+  bool ReadU16(uint16_t* value);
+  bool ReadU32(uint32_t* value);
+  bool ReadU64(uint64_t* value);
 
  private:
   // Hidden to promote type safety.
@@ -85,10 +87,10 @@ class BASE_EXPORT BigEndianWriter {
 
   bool Skip(size_t len);
   bool WriteBytes(const void* buf, size_t len);
-  bool WriteU8(uint8 value);
-  bool WriteU16(uint16 value);
-  bool WriteU32(uint32 value);
-  bool WriteU64(uint64 value);
+  bool WriteU8(uint8_t value);
+  bool WriteU16(uint16_t value);
+  bool WriteU32(uint32_t value);
+  bool WriteU64(uint64_t value);
 
  private:
   // Hidden to promote type safety.

diff --git a/base/big_endian_unittest.cc b/base/big_endian_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "base/big_endian.h"
 
+#include <stdint.h>
+
 #include "base/strings/string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -13,10 +15,10 @@ TEST(BigEndianReaderTest, ReadsValues) {
   char data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
                   0x1A, 0x2B, 0x3C, 0x4D, 0x5E };
   char buf[2];
-  uint8 u8;
-  uint16 u16;
-  uint32 u32;
-  uint64 u64;
+  uint8_t u8;
+  uint16_t u16;
+  uint32_t u32;
+  uint64_t u64;
   base::StringPiece piece;
   BigEndianReader reader(data, sizeof(data));
 
@@ -43,10 +45,10 @@ TEST(BigEndianReaderTest, ReadsValues) {
 TEST(BigEndianReaderTest, RespectsLength) {
   char data[8];
   char buf[2];
-  uint8 u8;
-  uint16 u16;
-  uint32 u32;
-  uint64 u64;
+  uint8_t u8;
+  uint16_t u16;
+  uint32_t u32;
+  uint64_t u64;
   base::StringPiece piece;
   BigEndianReader reader(data, sizeof(data));
   // 8 left
@@ -88,10 +90,10 @@ TEST(BigEndianWriterTest, WritesValues) {
 TEST(BigEndianWriterTest, RespectsLength) {
   char data[8];
   char buf[2];
-  uint8 u8 = 0;
-  uint16 u16 = 0;
-  uint32 u32 = 0;
-  uint64 u64 = 0;
+  uint8_t u8 = 0;
+  uint16_t u16 = 0;
+  uint32_t u32 = 0;
+  uint64_t u64 = 0;
   BigEndianWriter writer(data, sizeof(data));
   // 8 left
   EXPECT_FALSE(writer.Skip(9));

diff --git a/base/bind_helpers.h b/base/bind_helpers.h
@@ -143,13 +143,15 @@
 #ifndef BASE_BIND_HELPERS_H_
 #define BASE_BIND_HELPERS_H_
 
+#include <stddef.h>
+
 #include <type_traits>
 #include <utility>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/template_util.h"
+#include "build/build_config.h"
 
 namespace base {
 namespace internal {

diff --git a/base/bind_internal.h b/base/bind_internal.h
@@ -5,6 +5,8 @@
 #ifndef BASE_BIND_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
+#include <stddef.h>
+
 #include <type_traits>
 
 #include "base/bind_helpers.h"

diff --git a/base/bind_internal_win.h b/base/bind_internal_win.h
@@ -8,6 +8,8 @@
 #ifndef BASE_BIND_INTERNAL_WIN_H_
 #define BASE_BIND_INTERNAL_WIN_H_
 
+#include "build/build_config.h"
+
 // In the x64 architecture in Windows, __fastcall, __stdcall, etc, are all
 // the same as __cdecl which would turn the following specializations into
 // multiple definitions.

diff --git a/base/bind_unittest.cc b/base/bind_unittest.cc
@@ -8,9 +8,11 @@
 #include <utility>
 
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 

diff --git a/base/bind_unittest.nc b/base/bind_unittest.nc
@@ -5,8 +5,9 @@
 // This is a "No Compile Test" suite.
 // http://dev.chromium.org/developers/testing/no-compile-tests
 
-#include "base/callback.h"
 #include "base/bind.h"
+#include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 
 namespace base {