Add compile time checks against longs being used in IPC structs on 32 bit Android.

base/pickle.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_PICKLE_H_
 #define BASE_PICKLE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 27 matching lines @@
   // methods return true. Otherwise, false is returned to indicate that the
   // result could not be extracted. It is not possible to read from the iterator
   // after that.
   bool ReadBool(bool* result) WARN_UNUSED_RESULT;
   bool ReadInt(int* result) WARN_UNUSED_RESULT;
   bool ReadLong(long* result) WARN_UNUSED_RESULT;
   bool ReadUInt16(uint16_t* result) WARN_UNUSED_RESULT;
   bool ReadUInt32(uint32_t* result) WARN_UNUSED_RESULT;
   bool ReadInt64(int64_t* result) WARN_UNUSED_RESULT;
   bool ReadUInt64(uint64_t* result) WARN_UNUSED_RESULT;
-  bool ReadSizeT(size_t* result) WARN_UNUSED_RESULT;
   bool ReadFloat(float* result) WARN_UNUSED_RESULT;
   bool ReadDouble(double* result) WARN_UNUSED_RESULT;
   bool ReadString(std::string* result) WARN_UNUSED_RESULT;
   // The StringPiece data will only be valid for the lifetime of the message.
   bool ReadStringPiece(StringPiece* result) WARN_UNUSED_RESULT;
   bool ReadString16(string16* result) WARN_UNUSED_RESULT;
   // The StringPiece16 data will only be valid for the lifetime of the message.
   bool ReadStringPiece16(StringPiece16* result) WARN_UNUSED_RESULT;
 
   // A pointer to the data will be placed in |*data|, and the length will be
@@ skipping 56 matching lines @@
 class BASE_EXPORT PickleSizer {
  public:
   PickleSizer();
   ~PickleSizer();
 
   // Returns the computed size of the payload.
   size_t payload_size() const { return payload_size_; }
 
   void AddBool() { return AddInt(); }
   void AddInt() { AddPOD<int>(); }
-  void AddLongUsingDangerousNonPortableLessPersistableForm() { AddPOD<long>(); }
+  void AddLong() { AddPOD<uint64_t>(); }
   void AddUInt16() { return AddPOD<uint16_t>(); }
   void AddUInt32() { return AddPOD<uint32_t>(); }
   void AddInt64() { return AddPOD<int64_t>(); }
   void AddUInt64() { return AddPOD<uint64_t>(); }
-  void AddSizeT() { return AddPOD<uint64_t>(); }
   void AddFloat() { return AddPOD<float>(); }
   void AddDouble() { return AddPOD<double>(); }
   void AddString(const StringPiece& value);
   void AddString16(const StringPiece16& value);
   void AddData(int length);
   void AddBytes(int length);
 
  private:
   // Just like AddBytes() but with a compile-time size for performance.
   template<size_t length> void BASE_EXPORT AddBytesStatic();
@@ skipping 81 matching lines @@
   // appended to the end of the Pickle's payload.  When reading values from a
   // Pickle, it is important to read them in the order in which they were added
   // to the Pickle.
 
   bool WriteBool(bool value) {
     return WriteInt(value ? 1 : 0);
   }
   bool WriteInt(int value) {
     return WritePOD(value);
   }
-  // WARNING: DO NOT USE THIS METHOD IF PICKLES ARE PERSISTED IN ANY WAY.
-  // It will write whatever a "long" is on this architecture. On 32-bit
-  // platforms, it is 32 bits. On 64-bit platforms, it is 64 bits. If persisted
-  // pickles are still around after upgrading to 64-bit, or if they are copied
-  // between dissimilar systems, YOUR PICKLES WILL HAVE GONE BAD.
-  bool WriteLongUsingDangerousNonPortableLessPersistableForm(long value) {
-    return WritePOD(value);
+  bool WriteLong(long value) {
+    // Always write long as a 64-bit value to ensure compatibility between
+    // 32-bit and 64-bit processes.
+    return WritePOD(static_cast<int64_t>(value));
   }
   bool WriteUInt16(uint16_t value) { return WritePOD(value); }
   bool WriteUInt32(uint32_t value) { return WritePOD(value); }
   bool WriteInt64(int64_t value) { return WritePOD(value); }
   bool WriteUInt64(uint64_t value) { return WritePOD(value); }
-  bool WriteSizeT(size_t value) {
-    // Always write size_t as a 64-bit value to ensure compatibility between
-    // 32-bit and 64-bit processes.
-    return WritePOD(static_cast<uint64_t>(value));
-  }
   bool WriteFloat(float value) {
     return WritePOD(value);
   }
   bool WriteDouble(double value) {
     return WritePOD(value);
   }
   bool WriteString(const StringPiece& value);
   bool WriteString16(const StringPiece16& value);
   // "Data" is a blob with a length. When you read it out you will be given the
   // length. See also WriteBytes.
@@ skipping 126 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNextOverflow);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow);
 };
 
 }  // namespace base
 
 #endif  // BASE_PICKLE_H_