Refactor PickleIterator.

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"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 
 class Pickle;
 
 // PickleIterator reads data from a Pickle. The Pickle object must remain valid
 // while the PickleIterator object is in use.
 class BASE_EXPORT PickleIterator {
  public:
-  PickleIterator() : read_ptr_(NULL), read_end_ptr_(NULL) {}
+  PickleIterator() : payload_ptr_(NULL), read_index_(0), end_index_(0) {}
   explicit PickleIterator(const Pickle& pickle);
 
   // Methods for reading the payload of the Pickle. To read from the start of
   // the Pickle, create a PickleIterator from a Pickle. If successful, these
   // methods return true. Otherwise, false is returned to indicate that the
-  // result could not be extracted.
+  // 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 ReadFloat(float* result) WARN_UNUSED_RESULT;
   bool ReadString(std::string* result) WARN_UNUSED_RESULT;
   bool ReadWString(std::wstring* result) WARN_UNUSED_RESULT;
@@ skipping 16 matching lines @@
  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);
 
+  // Advance read_index_ but do not allow it to exceed end_index_.
+  // Keeps read_index_ aligned.
+  inline void Advance(size_t size);
+
   // Get read pointer for Type and advance read pointer.
   template<typename Type>
   inline const char* GetReadPointerAndAdvance();
 
   // Get read pointer for |num_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 int 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_;
+  const char* payload_ptr_;

[jar (doing other things), 2014/05/29 01:51:16]

nit:  Now that we're not advancing this ptr, perhaps just |payload_| would be a
better name.

Comments are often helpful. 

const char* payload_;  // Start of our pickle's payload.
size_t read_index_;  // Next readable byte is payload_[read_index_].
size_t end_index_;  // Index that is one char beyond the end of our payload_[].

[halyavin, 2014/05/29 07:34:55]

Done.

+  size_t read_index_;
+  size_t end_index_;
 
   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
@@ skipping 178 matching lines @@
     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_);
   }
 
   // The payload is the pickle data immediately following the header.
-  size_t payload_size() const { return header_->payload_size; }
+  size_t payload_size() const {
+    return header_ ? header_->payload_size : 0;
+  }
 
   const char* payload() const {
     return reinterpret_cast<const char*>(header_) + header_size_;
   }
 
   // Returns the address of the byte immediately following the currently valid
   // header + payload.
   const char* end_of_payload() const {
     // This object may be invalid.
     return header_ ? payload() + payload_size() : NULL;
@@ skipping 48 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__