Refactor Pickle Read methods to use higher performance PickleIterator.

base/pickle.h

 // Copyright (c) 2011 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__
 #pragma once
 
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/string16.h"
 
+class Pickle;
+
+// PickleReader reads data from a Pickle. The Pickle object must remain valid
+// while the PickleReader object is in use.
+class BASE_EXPORT PickleReader {
+ public:
+  PickleReader() : read_ptr_(NULL), read_end_ptr_(NULL) {}
+  explicit PickleReader(const Pickle& pickle);
+
+  // Methods for reading the payload of the Pickle. To read from the start of
+  // the Pickle, create a PickleReader from a Pickle. If successful, these
+  // methods return true. Otherwise, false is returned to indicate that the
+  // result could not be extracted.
+  bool ReadBool(bool* result) WARN_UNUSED_RESULT;
+  bool ReadInt(int* result) WARN_UNUSED_RESULT;
+  bool ReadLong(long* result) WARN_UNUSED_RESULT;
+  bool ReadSize(size_t* 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 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;
+
+  // 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 bytes
+  // available. Otherwise, does nothing and returns false.

[jar (doing other things), 2012/02/29 22:04:08]

The code suggests if this fails, that it nulls out the read_ptr_ and
read_end_ptr_.

[jbates, 2012/02/29 23:22:26]

Done.

+  bool SkipBytes(int num_bytes);
+
+ private:
+  // Aligns 'i' by rounding it up to the next multiple of 'alignment'
+  static size_t AlignInt(size_t i, int alignment) {
+    return i + (alignment - (i % alignment)) % alignment;
+  }
+
+  // Read Type from Pickle.
+  template <typename Type>
+  inline bool ReadBuiltinType(Type* result);
+
+  // Get read pointer for Type and advance read pointer.
+  template<typename Type>
+  inline const char* GetReadPointerAndAdvance();
+
+  // Get read pointer for |bytes| and advance read pointer. This method checks
+  // num_bytes for negativity and wrapping.
+  const char* GetReadPointerAndAdvance(int num_bytes);
+
+  // Get read pointer for (num_elements * size_element) bytes and advance read
+  // pointer. This method checks for overflow, negativity and wrapping.
+  inline const char* GetReadPointerAndAdvance(int num_elements,
+                                              size_t size_element);
+
+  // Pointers to the Pickle data.
+  const char* read_ptr_;
+  const char* read_end_ptr_;
+
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, GetReadPointerAndAdvance);
+};
+
 // This class provides facilities for basic binary value packing and unpacking.
 //
 // The Pickle class supports appending primitive values (ints, strings, etc.)
 // to a pickle instance.  The Pickle instance grows its internal memory buffer
 // dynamically to hold the sequence of primitive values.   The internal memory
 // buffer is exposed as the "data" of the Pickle.  This "data" can be passed
 // to a Pickle object to initialize it for reading.
 //
 // When reading from a Pickle object, it is important for the consumer to know
 // what value types to read and in what order to read them as the Pickle does
@@ skipping 32 matching lines @@
 
   // Performs a deep copy.
   Pickle& operator=(const Pickle& other);
 
   // Returns the size of the Pickle's data.
   size_t size() const { return header_size_ + header_->payload_size; }
 
   // Returns the data for this Pickle.
   const void* data() const { return header_; }
 
-  // Methods for reading the payload of the Pickle.  To read from the start of
-  // the Pickle, initialize *iter to NULL.  If successful, these methods return
-  // true.  Otherwise, false is returned to indicate that the result could not
-  // be extracted.
-  bool ReadBool(void** iter, bool* result) const;
-  bool ReadInt(void** iter, int* result) const;
-  bool ReadLong(void** iter, long* result) const;
-  bool ReadSize(void** iter, size_t* result) const;
-  bool ReadUInt16(void** iter, uint16* result) const;
-  bool ReadUInt32(void** iter, uint32* result) const;
-  bool ReadInt64(void** iter, int64* result) const;
-  bool ReadUInt64(void** iter, uint64* result) const;
-  bool ReadString(void** iter, std::string* result) const;
-  bool ReadWString(void** iter, std::wstring* result) const;
-  bool ReadString16(void** iter, string16* result) const;
-  bool ReadData(void** iter, const char** data, int* length) const;
-  bool ReadBytes(void** iter, const char** data, int length) const;
+  // For compatibility, these older style read methods pass through to the
+  // PickleReader methods.
+  // TODO(jbates) Remove these methods.
+  bool ReadBool(PickleReader* iter, bool* result) const {
+    return iter->ReadBool(result);
+  }
+  bool ReadInt(PickleReader* iter, int* result) const {
+    return iter->ReadInt(result);
+  }
+  bool ReadLong(PickleReader* iter, long* result) const {
+    return iter->ReadLong(result);
+  }
+  bool ReadSize(PickleReader* iter, size_t* result) const {
+    return iter->ReadSize(result);
+  }
+  bool ReadUInt16(PickleReader* iter, uint16* result) const {
+    return iter->ReadUInt16(result);
+  }
+  bool ReadUInt32(PickleReader* iter, uint32* result) const {
+    return iter->ReadUInt32(result);
+  }
+  bool ReadInt64(PickleReader* iter, int64* result) const {
+    return iter->ReadInt64(result);
+  }
+  bool ReadUInt64(PickleReader* iter, uint64* result) const {
+    return iter->ReadUInt64(result);
+  }
+  bool ReadString(PickleReader* iter, std::string* result) const {
+    return iter->ReadString(result);
+  }
+  bool ReadWString(PickleReader* iter, std::wstring* result) const {
+    return iter->ReadWString(result);
+  }
+  bool ReadString16(PickleReader* iter, string16* result) const {
+    return iter->ReadString16(result);
+  }
+  bool ReadData(PickleReader* iter, const char** data, int* length) const {
+    return iter->ReadData(data, length);
+  }
+  bool ReadBytes(PickleReader* iter, const char** data, int length) const {
+    return iter->ReadBytes(data, length);
+  }
 
   // Safer version of ReadInt() checks for the result not being negative.
   // Use it for reading the object sizes.
-  bool ReadLength(void** iter, int* result) const;
+  bool ReadLength(PickleReader* iter, int* result) const {
+    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
   // 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 WriteBytes(&value, sizeof(value));
@@ skipping 55 matching lines @@
   T* headerT() {
     DCHECK_EQ(header_size_, sizeof(T));
     return static_cast<T*>(header_);
   }
   template <class T>
   const T* headerT() const {
     DCHECK_EQ(header_size_, sizeof(T));
     return static_cast<const T*>(header_);
   }
 
-  // Returns true if the given iterator could point to data with the given
-  // length. If there is no room for the given data before the end of the
-  // payload, returns false.
-  bool IteratorHasRoomFor(const void* iter, int len) const {
-    if ((len < 0) || (iter < header_) || iter > end_of_payload())
-      return false;
-    const char* end_of_region = reinterpret_cast<const char*>(iter) + len;
-    // Watch out for overflow in pointer calculation, which wraps.
-    return (iter <= end_of_region) && (end_of_region <= end_of_payload());
-  }
-
  protected:
   size_t payload_size() const { return header_->payload_size; }
 
   char* payload() {
     return reinterpret_cast<char*>(header_) + header_size_;
   }
   const char* payload() const {
     return reinterpret_cast<const char*>(header_) + header_size_;
   }
 
@@ skipping 30 matching lines @@
   bool Resize(size_t new_capacity);
 
   // Aligns 'i' by rounding it up to the next multiple of 'alignment'
   static size_t AlignInt(size_t i, int alignment) {
     return i + (alignment - (i % alignment)) % alignment;
   }
 
   // Moves the iterator by the given number of bytes, making sure it is aligned.
   // Pointer (iterator) is NOT aligned, but the change in the pointer
   // is guaranteed to be a multiple of sizeof(uint32).
-  static void UpdateIter(void** iter, int bytes) {
-    *iter = static_cast<char*>(*iter) + AlignInt(bytes, sizeof(uint32));
+  static void UpdateIter(PickleReader* iter, int bytes) {
+    iter->SkipBytes(bytes);
   }
 
   // Find the end of the pickled data that starts at range_start.  Returns NULL
   // if the entire Pickle is not found in the given data range.
   static const char* FindNext(size_t header_size,
                               const char* range_start,
                               const char* range_end);
 
   // The allocation granularity of the payload.
   static const int kPayloadUnit;
 
  private:
+  friend class PickleReader;
+
   Header* header_;
   size_t header_size_;  // Supports extra data between header and payload.
   // Allocation size of payload (or -1 if allocation is const).
   size_t capacity_;
   size_t variable_buffer_offset_;  // IF non-zero, then offset to a buffer.
 
   FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
   FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, IteratorHasRoom);
 };
 
 #endif  // BASE_PICKLE_H__