Introduce Pickle::{Read,Write}PODArray to serialize arrays of POD

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 22 matching lines @@
   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 ReadFloat(float* result) WARN_UNUSED_RESULT;
   bool ReadString(std::string* result) WARN_UNUSED_RESULT;
   bool ReadWString(std::wstring* result) WARN_UNUSED_RESULT;
   bool ReadString16(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;
+  template<size_t n, typename T>
+  bool ReadPODArray(const T** data) WARN_UNUSED_RESULT {
+    const char* char_data;
+    if (!ReadBytes(&char_data, sizeof(T[n])))
+      return false;
+    *data = reinterpret_cast<const T*>(char_data);
+    return true;
+  }
 
   // Safer version of ReadInt() checks for the result not being negative.
   // Use it for reading the object sizes.
   bool ReadLength(int* result) WARN_UNUSED_RESULT {
     return ReadInt(result) && *result >= 0;
   }
 
   // Skips bytes in the read buffer and returns true if there are at least
   // num_bytes available. Otherwise, does nothing and returns false.
   bool SkipBytes(int num_bytes) WARN_UNUSED_RESULT {
@@ skipping 140 matching lines @@
   }
   // A pointer to the data will be placed in *data. The caller specifies the
   // number of bytes to read, and ReadBytes will validate this length. The
   // returned buffer will be into the message's buffer so will be scoped to the
   // lifetime of the message (or until the message data is mutated).
   bool ReadBytes(PickleIterator* iter,
                  const char** data,
                  int length) const WARN_UNUSED_RESULT {
     return iter->ReadBytes(data, length);
   }
+  // A pointer to the data will be placed in *data. The caller specifies the
+  // number of objects to read as a template parameter. The returned buffer will
+  // be into the message's buffer so will be scoped to the lifetime of the
+  // message (or until the message data is mutated).
+  // Example usage:
+  // const Type* data;
+  // if (pickle.ReadPODArray<4>(&data)) {
+  //   DoSomething(data[0], data[1], data[2], data[3]);
+  // }
+  template<size_t n, typename T> bool ReadPODArray(
+      PickleIterator* iter,
+      const T** data) const WARN_UNUSED_RESULT {
+    return iter->ReadPODArray<n>(data);
+  }
 
   // Safer version of ReadInt() checks for the result not being negative.
   // Use it for reading the object sizes.
   bool ReadLength(PickleIterator* iter,
                   int* result) const  WARN_UNUSED_RESULT {
     return iter->ReadLength(result);
   }
 
   // Methods for adding to the payload of the Pickle.  These values are
   // appended to the end of the Pickle's payload.  When reading values from a
@@ skipping 32 matching lines @@
   bool WriteWString(const std::wstring& value);
   bool WriteString16(const string16& value);
   // "Data" is a blob with a length. When you read it out you will be given the
   // length. See also WriteBytes.
   bool WriteData(const char* data, int length);
   // "Bytes" is a blob with no length. The caller must specify the length both
   // when reading and writing. It is normally used to serialize PoD types of a
   // known size. See also WriteData.
   bool WriteBytes(const void* data, int length);
 
+  // Writes a fixed-size POD array by copying its bytes. Use as:
+  // Type data[4] = {...}
+  // pickle.WritePODArray<4>(data);
+  template <size_t n, typename T> void WritePODArray(const T* data) {
+    WriteBytesStatic<sizeof(T[n])>(data);
+  }
+
   // Reserves space for upcoming writes when multiple writes will be made and
   // their sizes are computed in advance. It can be significantly faster to call
   // Reserve() before calling WriteFoo() multiple times.
   void Reserve(size_t additional_capacity);
 
   // Payload follows after allocation of Header (header size is customizable).
   struct Header {
     uint32 payload_size;  // Specifies the size of the payload.
   };
 
@@ skipping 73 matching lines @@
     return true;
   }
   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);
 };
 
 #endif  // BASE_PICKLE_H__