Revert of Remove deprecated methods from Pickle.

base/pickle_unittest.cc

 // 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.
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/string16.h"
@@ skipping 20 matching lines @@
 const std::wstring testwstring(L"Hello, world");
 const base::string16 teststring16(base::ASCIIToUTF16("Hello, world"));
 const char testdata[] = "AAA\0BBB\0";
 const int testdatalen = arraysize(testdata) - 1;
 
 // checks that the result
 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
 
 TEST(PickleTest, EncodeDecode) {
   Pickle pickle;
 
   EXPECT_TRUE(pickle.WriteBool(testbool1));
   EXPECT_TRUE(pickle.WriteBool(testbool2));
   EXPECT_TRUE(pickle.WriteInt(testint));
@@ skipping 29 matching lines @@
   Pickle pickle;
   // Under the hood size_t is always written as a 64-bit value, so simulate a
   // 64-bit size_t even on 32-bit architectures by explicitly writing a uint64.
   EXPECT_TRUE(pickle.WriteUInt64(testuint64));
 
   PickleIterator iter(pickle);
   size_t outsizet;
   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);
   }
 }
 
 // Tests that we can handle really small buffers.
 TEST(PickleTest, SmallBuffer) {
   scoped_ptr<char[]> buffer(new char[1]);
 
   // We should not touch the buffer.
   Pickle pickle(buffer.get(), 1);
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 // Tests that we can handle improper headers.
 TEST(PickleTest, BigSize) {
   int buffer[] = { 0x56035200, 25, 40, 50 };
 
   Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer));
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 TEST(PickleTest, UnalignedSize) {
   int buffer[] = { 10, 25, 40, 50 };
 
   Pickle pickle(reinterpret_cast<char*>(buffer), sizeof(buffer));
 
   PickleIterator iter(pickle);
   int data;
-  EXPECT_FALSE(iter.ReadInt(&data));
+  EXPECT_FALSE(pickle.ReadInt(&iter, &data));
 }
 
 TEST(PickleTest, ZeroLenStr) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteString(std::string()));
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_TRUE(iter.ReadString(&outstr));
+  EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
   EXPECT_EQ("", outstr);
 }
 
 TEST(PickleTest, ZeroLenWStr) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteWString(std::wstring()));
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_TRUE(iter.ReadString(&outstr));
+  EXPECT_TRUE(pickle.ReadString(&iter, &outstr));
   EXPECT_EQ("", outstr);
 }
 
 TEST(PickleTest, BadLenStr) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteInt(-2));
 
   PickleIterator iter(pickle);
   std::string outstr;
-  EXPECT_FALSE(iter.ReadString(&outstr));
+  EXPECT_FALSE(pickle.ReadString(&iter, &outstr));
 }
 
 TEST(PickleTest, BadLenWStr) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteInt(-1));
 
   PickleIterator iter(pickle);
   std::wstring woutstr;
-  EXPECT_FALSE(iter.ReadWString(&woutstr));
+  EXPECT_FALSE(pickle.ReadWString(&iter, &woutstr));
 }
 
 TEST(PickleTest, FindNext) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteInt(1));
   EXPECT_TRUE(pickle.WriteString("Domo"));
 
   const char* start = reinterpret_cast<const char*>(pickle.data());
   const char* end = start + pickle.size();
 
@@ skipping 107 matching lines @@
   const uint32 kMagic = 0x12345678;
 
   Pickle pickle(sizeof(CustomHeader));
   pickle.WriteInt(kMagic);
 
   // this should not overwrite the 'int' payload
   pickle.headerT<CustomHeader>()->blah = 10;
 
   PickleIterator iter(pickle);
   int result;
-  ASSERT_TRUE(iter.ReadInt(&result));
+  ASSERT_TRUE(pickle.ReadInt(&iter, &result));
 
   EXPECT_EQ(static_cast<uint32>(result), kMagic);
 }
 
 TEST(PickleTest, EqualsOperator) {
   Pickle source;
   source.WriteInt(1);
 
   Pickle copy_refs_source_buffer(static_cast<const char*>(source.data()),
                                  source.size());
   Pickle copy;
   copy = copy_refs_source_buffer;
   ASSERT_EQ(source.size(), copy.size());
 }
 
 TEST(PickleTest, EvilLengths) {
   Pickle source;
   std::string str(100000, 'A');
   EXPECT_TRUE(source.WriteData(str.c_str(), 100000));
   // ReadString16 used to have its read buffer length calculation wrong leading
   // 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.
   // (1<<31) * sizeof(char16) == 0, so this is particularly evil.
   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.
 TEST(PickleTest, ZeroLength) {
   Pickle pickle;
   EXPECT_TRUE(pickle.WriteData(NULL, 0));
 
   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.
 }
 
 // Check that ReadBytes works properly with an iterator initialized to NULL.
 TEST(PickleTest, ReadBytes) {
   Pickle pickle;
   int data = 0x7abcd;
   EXPECT_TRUE(pickle.WriteBytes(&data, sizeof(data)));
 
   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));
   EXPECT_EQ(data, outdata);
 }