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

base/pickle.cc

 // 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.
 
 #include "base/pickle.h"
 
 #include <stdlib.h>
 
 #include <algorithm>  // for max()
 
@@ skipping 88 matching lines @@
 }
 
 bool PickleIterator::ReadInt64(int64* result) {
   return ReadBuiltinType(result);
 }
 
 bool PickleIterator::ReadUInt64(uint64* result) {
   return ReadBuiltinType(result);
 }
 
+bool PickleIterator::ReadSizeT(size_t* result) {
+  // Always read size_t as a 64-bit value to ensure compatibility between 32-bit
+  // and 64-bit processes.
+  uint64 result_uint64 = 0;
+  bool success = ReadBuiltinType(&result_uint64);
+  *result = static_cast<size_t>(result_uint64);

[Tom Sepez, 2014/10/01 19:12:45]

I'd be OK with this so long as we did a check that result_uint64 <
std::numeric_limits<size_t>::max, returning false if it isnt.  In that case,
when you are sending too big a value from 64 to 32, we fail hard.

[Peter Kasting, 2014/10/01 19:42:08]

Sure.  Changed static_cast to checked_cast to achieve this.

+  return success;
+}
+
 bool PickleIterator::ReadFloat(float* result) {
   // crbug.com/315213
   // The source data may not be properly aligned, and unaligned float reads
   // cause SIGBUS on some ARM platforms, so force using memcpy to copy the data
   // into the result.
   const char* read_from = GetReadPointerAndAdvance<float>();
   if (!read_from)
     return false;
   memcpy(result, read_from, sizeof(*result));
   return true;
@@ skipping 234 matching lines @@
   if (new_size > capacity_after_header_) {
     Resize(std::max(capacity_after_header_ * 2, new_size));
   }
 
   char* write = mutable_payload() + write_offset_;
   memcpy(write, data, length);
   memset(write + length, 0, data_len - length);
   header_->payload_size = static_cast<uint32>(new_size);
   write_offset_ = new_size;
 }