Revert of Remove deprecated methods from Pickle.

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() : payload_(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. It is not possible to read from the iterator
+  // 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;
-
-  // A pointer to the data will be placed in |*data|, and the length will be
-  // placed in |*length|. The pointer placed into |*data| points into the
-  // message's buffer so it will be scoped to the lifetime of the message (or
-  // until the message data is mutated). Do not keep the pointer around!
   bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT;
-
-  // 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
-  // pointer placed into |*data| points into the message's buffer so it will be
-  // scoped to the lifetime of the message (or until the message data is
-  // mutated). Do not keep the pointer around!
   bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT;
 
-  // A safer version of ReadInt() that checks for the result not being negative.
+  // 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 {
     return !!GetReadPointerAndAdvance(num_bytes);
   }
 
  private:
-  // Aligns 'i' by rounding it up to the next multiple of 'alignment'.
+  // 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>
   bool ReadBuiltinType(Type* result);
 
   // Advance read_index_ but do not allow it to exceed end_index_.
   // Keeps read_index_ aligned.
@@ skipping 64 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_; }
 
+  // For compatibility, these older style read methods pass through to the
+  // PickleIterator methods.
+  // TODO(jbates) Remove these methods.
+  bool ReadBool(PickleIterator* iter,
+                bool* result) const WARN_UNUSED_RESULT {
+    return iter->ReadBool(result);
+  }
+  bool ReadInt(PickleIterator* iter,
+               int* result) const WARN_UNUSED_RESULT {
+    return iter->ReadInt(result);
+  }
+  bool ReadLong(PickleIterator* iter,
+                long* result) const WARN_UNUSED_RESULT {
+    return iter->ReadLong(result);
+  }
+  bool ReadUInt16(PickleIterator* iter,
+                  uint16* result) const WARN_UNUSED_RESULT {
+    return iter->ReadUInt16(result);
+  }
+  bool ReadUInt32(PickleIterator* iter,
+                  uint32* result) const WARN_UNUSED_RESULT {
+    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 {
+    return iter->ReadString(result);
+  }
+  bool ReadWString(PickleIterator* iter,
+                   std::wstring* result) const WARN_UNUSED_RESULT {
+    return iter->ReadWString(result);
+  }
+  bool ReadString16(PickleIterator* iter,
+                    base::string16* result) const WARN_UNUSED_RESULT {
+    return iter->ReadString16(result);
+  }
+  // A pointer to the data will be placed in *data, and the length will be
+  // placed in *length. This 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 ReadData(PickleIterator* iter,
+                const char** data,
+                int* length) const WARN_UNUSED_RESULT {
+    return iter->ReadData(data, length);
+  }
+  // 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);
+  }
+
+  // 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
   // 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 WritePOD(value);
   }
   // WARNING: DO NOT USE THIS METHOD IF PICKLES ARE PERSISTED IN ANY WAY.
   // It will write whatever a "long" is on this architecture. On 32-bit
   // platforms, it is 32 bits. On 64-bit platforms, it is 64 bits. If persisted
   // pickles are still around after upgrading to 64-bit, or if they are copied
@@ skipping 124 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__