Revert of Remove deprecated methods from Pickle. (patchset #10 id:180001 of https://codereview.chromium.org/818833004/)

Reason for revert:
Allegedly causes a performance hit: http://crbug.com/445173

Original issue's description:
> Remove deprecated methods from Pickle.
>
> BUG=444578
> TEST=none
> R=nasko@chromium.org
> TBR=ben@chromium.org
>
> Committed: https://chromium.googlesource.com/chromium/src/+/b740bfe23ae7ad244356a4a7538b95ae560251db

TBR=nasko@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=444578

Review URL: https://codereview.chromium.org/825353003

Cr-Commit-Position: refs/heads/master@{#309689}

2 files changed, 116 insertions, 47 deletions

diff --git a/base/pickle.h b/base/pickle.h
index f2a198e..11cf484 100644
--- a/base/pickle.h
+++ b/base/pickle.h
@@ -26,7 +26,7 @@ class BASE_EXPORT PickleIterator {
   // 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;
@@ -41,21 +41,10 @@ class BASE_EXPORT PickleIterator {
   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;
@@ -68,7 +57,7 @@ class BASE_EXPORT PickleIterator {
   }
 
  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;
   }
@@ -153,11 +142,91 @@ class BASE_EXPORT Pickle {
   // 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);
   }
diff --git a/base/pickle_unittest.cc b/base/pickle_unittest.cc
index 1fa1f32..20a8d67 100644
--- a/base/pickle_unittest.cc
+++ b/base/pickle_unittest.cc
@@ -38,67 +38,67 @@ void VerifyResult(const Pickle& pickle) {
   PickleIterator iter(pickle);
 
   bool outbool;
-  EXPECT_TRUE(iter.ReadBool(&outbool));
+  EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
   EXPECT_FALSE(outbool);
-  EXPECT_TRUE(iter.ReadBool(&outbool));
+  EXPECT_TRUE(pickle.ReadBool(&iter, &outbool));
   EXPECT_TRUE(outbool);
 
   int outint;
-  EXPECT_TRUE(iter.ReadInt(&outint));
+  EXPECT_TRUE(pickle.ReadInt(&iter, &outint));
   EXPECT_EQ(testint, outint);
 
   long outlong;
-  EXPECT_TRUE(iter.ReadLong(&outlong));
+  EXPECT_TRUE(pickle.ReadLong(&iter, &outlong));
   EXPECT_EQ(testlong, outlong);
 
   uint16 outuint16;
-  EXPECT_TRUE(iter.ReadUInt16(&outuint16));
+  EXPECT_TRUE(pickle.ReadUInt16(&iter, &outuint16));
   EXPECT_EQ(testuint16, outuint16);
 
   uint32 outuint32;
-  EXPECT_TRUE(iter.ReadUInt32(&outuint32));
+  EXPECT_TRUE(pickle.ReadUInt32(&iter, &outuint32));
   EXPECT_EQ(testuint32, outuint32);
 
   int64 outint64;
-  EXPECT_TRUE(iter.ReadInt64(&outint64));
+  EXPECT_TRUE(pickle.ReadInt64(&iter, &outint64));
   EXPECT_EQ(testint64, outint64);
 
   uint64 outuint64;
-  EXPECT_TRUE(iter.ReadUInt64(&outuint64));
+  EXPECT_TRUE(pickle.ReadUInt64(&iter, &outuint64));
   EXPECT_EQ(testuint64, outuint64);
 
   size_t outsizet;
-  EXPECT_TRUE(iter.ReadSizeT(&outsizet));
+  EXPECT_TRUE(pickle.ReadSizeT(&iter, &outsizet));
   EXPECT_EQ(testsizet, outsizet);
 
   float outfloat;
-  EXPECT_TRUE(iter.ReadFloat(&outfloat));
+  EXPECT_TRUE(pickle.ReadFloat(&iter, &outfloat));
   EXPECT_EQ(testfloat, outfloat);
 
   double outdouble;
-  EXPECT_TRUE(iter.ReadDouble(&outdouble));
+  EXPECT_TRUE(pickle.ReadDouble(&iter, &outdouble));
   EXPECT_EQ(testdouble, outdouble);
 
   std::string outstring;
-  EXPECT_TRUE(iter.ReadString(&outstring));
+  EXPECT_TRUE(pickle.ReadString(&iter, &outstring));
   EXPECT_EQ(teststring, outstring);
 
   std::wstring outwstring;
-  EXPECT_TRUE(iter.ReadWString(&outwstring));
+  EXPECT_TRUE(pickle.ReadWString(&iter, &outwstring));
   EXPECT_EQ(testwstring, outwstring);
 
   base::string16 outstring16;
-  EXPECT_TRUE(iter.ReadString16(&outstring16));
+  EXPECT_TRUE(pickle.ReadString16(&iter, &outstring16));
   EXPECT_EQ(teststring16, outstring16);
 
   const char* outdata;
   int outdatalen;
-  EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen));
+  EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
   EXPECT_EQ(testdatalen, outdatalen);
   EXPECT_EQ(memcmp(testdata, outdata, outdatalen), 0);
 
   // reads past the end should fail
-  EXPECT_FALSE(iter.ReadInt(&outint));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &outint));
 }
 
 }  // namespace
@@ -148,9 +148,9 @@ TEST(PickleTest, SizeTFrom64Bit) {
   if (sizeof(size_t) < sizeof(uint64)) {
     // ReadSizeT() should return false when the original written value can't be
     // represented as a size_t.
-    EXPECT_FALSE(iter.ReadSizeT(&outsizet));
+    EXPECT_FALSE(pickle.ReadSizeT(&iter, &outsizet));
   } else {
-    EXPECT_TRUE(iter.ReadSizeT(&outsizet));
+    EXPECT_TRUE(pickle.ReadSizeT(&iter, &outsizet));
     EXPECT_EQ(testuint64, outsizet);
   }
 }
@@ -164,7 +164,7 @@ TEST(PickleTest, SmallBuffer) {
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 // Tests that we can handle improper headers.
@@ -175,7 +175,7 @@ TEST(PickleTest, BigSize) {
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 TEST(PickleTest, UnalignedSize) {
@@ -185,7 +185,7 @@ TEST(PickleTest, UnalignedSize) {
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 TEST(PickleTest, ZeroLenStr) {
@@ -194,7 +194,7 @@ TEST(PickleTest, ZeroLenStr) {
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_TRUE(iter.ReadString(&outstr));
+  EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
   EXPECT_EQ("", outstr);
 }
 
@@ -204,7 +204,7 @@ TEST(PickleTest, ZeroLenWStr) {
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_TRUE(iter.ReadString(&outstr));
+  EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
   EXPECT_EQ("", outstr);
 }
 
@@ -214,7 +214,7 @@ TEST(PickleTest, BadLenStr) {
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_FALSE(iter.ReadString(&outstr));
+  EXPECT_FALSE(pickle.ReadString(&iter, &outstr));
 }
 
 TEST(PickleTest, BadLenWStr) {
@@ -223,7 +223,7 @@ TEST(PickleTest, BadLenWStr) {
 
   PickleIterator iter(pickle);
   std::wstring woutstr;
-  EXPECT_FALSE(iter.ReadWString(&woutstr));
+  EXPECT_FALSE(pickle.ReadWString(&iter, &woutstr));
 }
 
 TEST(PickleTest, FindNext) {
@@ -351,7 +351,7 @@ TEST(PickleTest, HeaderPadding) {
 
   PickleIterator iter(pickle);
   int result;
-  ASSERT_TRUE(iter.ReadInt(&result));
+  ASSERT_TRUE(pickle.ReadInt(&iter, &result));
 
   EXPECT_EQ(static_cast<uint32>(result), kMagic);
 }
@@ -375,14 +375,14 @@ TEST(PickleTest, EvilLengths) {
   // to out-of-bounds reading.
   PickleIterator iter(source);
   string16 str16;
-  EXPECT_FALSE(iter.ReadString16(&str16));
+  EXPECT_FALSE(source.ReadString16(&iter, &str16));
 
   // And check we didn't break ReadString16.
   str16 = (wchar_t) 'A';
   Pickle str16_pickle;
   EXPECT_TRUE(str16_pickle.WriteString16(str16));
   iter = PickleIterator(str16_pickle);
-  EXPECT_TRUE(iter.ReadString16(&str16));
+  EXPECT_TRUE(str16_pickle.ReadString16(&iter, &str16));
   EXPECT_EQ(1U, str16.length());
 
   // Check we don't fail in a length check with invalid String16 size.
@@ -390,14 +390,14 @@ TEST(PickleTest, EvilLengths) {
   Pickle bad_len;
   EXPECT_TRUE(bad_len.WriteInt(1 << 31));
   iter = PickleIterator(bad_len);
-  EXPECT_FALSE(iter.ReadString16(&str16));
+  EXPECT_FALSE(bad_len.ReadString16(&iter, &str16));
 
   // Check we don't fail in a length check with large WStrings.
   Pickle big_len;
   EXPECT_TRUE(big_len.WriteInt(1 << 30));
   iter = PickleIterator(big_len);
   std::wstring wstr;
-  EXPECT_FALSE(iter.ReadWString(&wstr));
+  EXPECT_FALSE(big_len.ReadWString(&iter, &wstr));
 }
 
 // Check we can write zero bytes of data and 'data' can be NULL.
@@ -408,7 +408,7 @@ TEST(PickleTest, ZeroLength) {
   PickleIterator iter(pickle);
   const char* outdata;
   int outdatalen;
-  EXPECT_TRUE(iter.ReadData(&outdata, &outdatalen));
+  EXPECT_TRUE(pickle.ReadData(&iter, &outdata, &outdatalen));
   EXPECT_EQ(0, outdatalen);
   // We can't assert that outdata is NULL.
 }
@@ -421,7 +421,7 @@ TEST(PickleTest, ReadBytes) {
 
   PickleIterator iter(pickle);
   const char* outdata_char = NULL;
-  EXPECT_TRUE(iter.ReadBytes(&outdata_char, sizeof(data)));
+  EXPECT_TRUE(pickle.ReadBytes(&iter, &outdata_char, sizeof(data)));
 
   int outdata;
   memcpy(&outdata, outdata_char, sizeof(outdata));