Add Read/WriteSizeT() functions to the pickle layer, plus one consumer.

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 <string>
 
 #include "base/base_export.h"
@@ skipping 17 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 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* result) WARN_UNUSED_RESULT;
   bool ReadUInt32(uint32* result) WARN_UNUSED_RESULT;
   bool ReadInt64(int64* result) WARN_UNUSED_RESULT;
   bool ReadUInt64(uint64* 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;
   bool ReadWString(std::wstring* result) WARN_UNUSED_RESULT;
   bool ReadString16(base::string16* result) WARN_UNUSED_RESULT;
   bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT;
   bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT;
 
   // Safer version of ReadInt() checks for the result not being negative.
   // Use it for reading the object sizes.
@@ skipping 117 matching lines @@
     return iter->ReadUInt32(result);
   }
   bool ReadInt64(PickleIterator* iter,
                  int64* result) const WARN_UNUSED_RESULT {
     return iter->ReadInt64(result);
   }
   bool ReadUInt64(PickleIterator* iter,
                   uint64* result) const WARN_UNUSED_RESULT {
     return iter->ReadUInt64(result);
   }
+  bool ReadSizeT(PickleIterator* iter,
+                 size_t* result) const WARN_UNUSED_RESULT {
+    return iter->ReadSizeT(result);
+  }
   bool ReadFloat(PickleIterator* iter,
                  float* result) const WARN_UNUSED_RESULT {
     return iter->ReadFloat(result);
   }
   bool ReadDouble(PickleIterator* iter,
                   double* result) const WARN_UNUSED_RESULT {
     return iter->ReadDouble(result);
   }
   bool ReadString(PickleIterator* iter,
                   std::string* result) const WARN_UNUSED_RESULT {
@@ skipping 56 matching lines @@
   }
   bool WriteUInt32(uint32 value) {
     return WritePOD(value);
   }
   bool WriteInt64(int64 value) {
     return WritePOD(value);
   }
   bool WriteUInt64(uint64 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>(value));
+  }
   bool WriteFloat(float value) {
     return WritePOD(value);
   }
   bool WriteDouble(double value) {
     return WritePOD(value);
   }
   bool WriteString(const std::string& value);
   bool WriteWString(const std::wstring& value);
   bool WriteString16(const base::string16& value);
   // "Data" is a blob with a length. When you read it out you will be given the
@@ skipping 93 matching lines @@
   }
   inline void WriteBytesCommon(const void* data, size_t length);
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow);
 };
 
 #endif  // BASE_PICKLE_H__