BinaryStream: Preserve 64-bit integer data.

Previously the code would truncate 64-bit data to fit in 32-bits.
This ran into a serialization bug when expanding a 64-bit mask.
The new blend state masks for extended range were out of range for
the 32-bit promotion that was happening before.

Also refactors how we capture bools and enums to be more consistent.

size_t is now correctly saved and loaded as 64-bits.

Bug: angleproject:5247
Change-Id: I452a98c1b0add4c0cf45493032e9310e7d8321b2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2497561
Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>

Author: null77

src/libANGLE/BinaryStream.h

@@ -19,6 +19,14 @@
 
 namespace gl
 {
+template <typename IntT>
+struct PromotedIntegerType
+{
+    using type = typename std::conditional<
+        std::is_signed<IntT>::value,
+        typename std::conditional<sizeof(IntT) <= 4, int32_t, int64_t>::type,
+        typename std::conditional<sizeof(IntT) <= 4, uint32_t, uint64_t>::type>::type;
+};
 
 class BinaryInputStream : angle::NonCopyable
 {
@@ -35,8 +43,11 @@ class BinaryInputStream : angle::NonCopyable
     template <class IntT>
     IntT readInt()
     {
-        int value = 0;
+        static_assert(!std::is_same<bool, std::remove_cv<IntT>()>(), "Use readBool");
+        using PromotedIntT = typename PromotedIntegerType<IntT>::type;
+        PromotedIntT value = 0;
         read(&value);
+        ASSERT(angle::IsValueInRangeForNumericType<IntT>(value));
         return static_cast<IntT>(value);
     }
 
@@ -49,8 +60,8 @@ class BinaryInputStream : angle::NonCopyable
     template <class IntT, class VectorElementT>
     void readIntVector(std::vector<VectorElementT> *param)
     {
-        unsigned int size = readInt<unsigned int>();
-        for (unsigned int index = 0; index < size; ++index)
+        size_t size = readInt<size_t>();
+        for (size_t index = 0; index < size; ++index)
         {
             param->push_back(readInt<IntT>());
         }
@@ -186,8 +197,8 @@ class BinaryOutputStream : angle::NonCopyable
     template <class IntT>
     void writeInt(IntT param)
     {
-        using PromotedIntT =
-            typename std::conditional<std::is_signed<IntT>::value, int, unsigned>::type;
+        static_assert(!std::is_same<bool, std::remove_cv<IntT>()>(), "Use writeBool");
+        using PromotedIntT = typename PromotedIntegerType<IntT>::type;
         ASSERT(angle::IsValueInRangeForNumericType<PromotedIntT>(param));
         PromotedIntT intValue = static_cast<PromotedIntT>(param);
         write(&intValue, 1);
@@ -232,22 +243,28 @@ class BinaryOutputStream : angle::NonCopyable
 
     void writeBytes(const unsigned char *bytes, size_t count) { write(bytes, count); }
 
+    void writeBool(bool value)
+    {
+        int intValue = value ? 1 : 0;
+        write(&intValue, 1);
+    }
+
     size_t length() const { return mData.size(); }
 
     const void *data() const { return mData.size() ? &mData[0] : nullptr; }
 
     const std::vector<uint8_t> &getData() const { return mData; }
 
   private:
-    std::vector<uint8_t> mData;
-
     template <typename T>
     void write(const T *v, size_t num)
     {
         static_assert(std::is_fundamental<T>::value, "T must be a fundamental type.");
         const char *asBytes = reinterpret_cast<const char *>(v);
         mData.insert(mData.end(), asBytes, asBytes + num * sizeof(T));
     }
+
+    std::vector<uint8_t> mData;
 };
 
 inline BinaryOutputStream::BinaryOutputStream() {}