Remove deprecated methods from Pickle.

content/common/page_state_serialization.cc

 // Copyright 2013 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 "content/common/page_state_serialization.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/pickle.h"
@@ skipping 193 matching lines @@
 // A bunch of convenience functions to read/write to SerializeObjects.  The
 // de-serializers assume the input data will be in the correct format and fall
 // back to returning safe defaults when not.
 
 void WriteData(const void* data, int length, SerializeObject* obj) {
   obj->pickle.WriteData(static_cast<const char*>(data), length);
 }
 
 void ReadData(SerializeObject* obj, const void** data, int* length) {
   const char* tmp;
-  if (obj->pickle.ReadData(&obj->iter, &tmp, length)) {
+  if (obj->iter.ReadData(&tmp, length)) {
     *data = tmp;
   } else {
     obj->parse_error = true;
     *data = NULL;
     *length = 0;
   }
 }
 
 void WriteInteger(int data, SerializeObject* obj) {
   obj->pickle.WriteInt(data);
 }
 
 int ReadInteger(SerializeObject* obj) {
   int tmp;
-  if (obj->pickle.ReadInt(&obj->iter, &tmp))
+  if (obj->iter.ReadInt(&tmp))
     return tmp;
   obj->parse_error = true;
   return 0;
 }
 
 void WriteInteger64(int64 data, SerializeObject* obj) {
   obj->pickle.WriteInt64(data);
 }
 
 int64 ReadInteger64(SerializeObject* obj) {
   int64 tmp = 0;
-  if (obj->pickle.ReadInt64(&obj->iter, &tmp))
+  if (obj->iter.ReadInt64(&tmp))
     return tmp;
   obj->parse_error = true;
   return 0;
 }
 
 void WriteReal(double data, SerializeObject* obj) {
   WriteData(&data, sizeof(double), obj);
 }
 
 double ReadReal(SerializeObject* obj) {
   const void* tmp = NULL;
   int length = 0;
   double value = 0.0;
   ReadData(obj, &tmp, &length);
   if (length == static_cast<int>(sizeof(double))) {
     // Use memcpy, as tmp may not be correctly aligned.
     memcpy(&value, tmp, sizeof(double));
   } else {
     obj->parse_error = true;
   }
   return value;
 }
 
 void WriteBoolean(bool data, SerializeObject* obj) {
   obj->pickle.WriteInt(data ? 1 : 0);
 }
 
 bool ReadBoolean(SerializeObject* obj) {
   bool tmp;
-  if (obj->pickle.ReadBool(&obj->iter, &tmp))
+  if (obj->iter.ReadBool(&tmp))
     return tmp;
   obj->parse_error = true;
   return false;
 }
 
 void WriteGURL(const GURL& url, SerializeObject* obj) {
   obj->pickle.WriteString(url.possibly_invalid_spec());
 }
 
 GURL ReadGURL(SerializeObject* obj) {
   std::string spec;
-  if (obj->pickle.ReadString(&obj->iter, &spec))
+  if (obj->iter.ReadString(&spec))
     return GURL(spec);
   obj->parse_error = true;
   return GURL();
 }
 
 void WriteStdString(const std::string& s, SerializeObject* obj) {
   obj->pickle.WriteString(s);
 }
 
 std::string ReadStdString(SerializeObject* obj) {
   std::string s;
-  if (obj->pickle.ReadString(&obj->iter, &s))
+  if (obj->iter.ReadString(&s))
     return s;
   obj->parse_error = true;
   return std::string();
 }
 
 // WriteString pickles the NullableString16 as <int length><char16* data>.
 // If length == -1, then the NullableString16 itself is null.  Otherwise the
 // length is the number of char16 (not bytes) in the NullableString16.
 void WriteString(const base::NullableString16& str, SerializeObject* obj) {
   if (str.is_null()) {
     obj->pickle.WriteInt(-1);
   } else {
     const base::char16* data = str.string().data();
     size_t length_in_bytes = str.string().length() * sizeof(base::char16);
 
     CHECK_LT(length_in_bytes,
              static_cast<size_t>(std::numeric_limits<int>::max()));
     obj->pickle.WriteInt(length_in_bytes);
     obj->pickle.WriteBytes(data, length_in_bytes);
   }
 }
 
 // This reads a serialized NullableString16 from obj. If a string can't be
 // read, NULL is returned.
 const base::char16* ReadStringNoCopy(SerializeObject* obj, int* num_chars) {
   int length_in_bytes;
-  if (!obj->pickle.ReadInt(&obj->iter, &length_in_bytes)) {
+  if (!obj->iter.ReadInt(&length_in_bytes)) {
     obj->parse_error = true;
     return NULL;
   }
 
   if (length_in_bytes < 0)
     return NULL;
 
   const char* data;
-  if (!obj->pickle.ReadBytes(&obj->iter, &data, length_in_bytes)) {
+  if (!obj->iter.ReadBytes(&data, length_in_bytes)) {
     obj->parse_error = true;
     return NULL;
   }
 
   if (num_chars)
     *num_chars = length_in_bytes / sizeof(base::char16);
   return reinterpret_cast<const base::char16*>(data);
 }
 
 base::NullableString16 ReadString(SerializeObject* obj) {
@@ skipping 399 matching lines @@
     float device_scale_factor,
     ExplodedPageState* exploded) {
   g_device_scale_factor_for_testing = device_scale_factor;
   bool rv = DecodePageState(encoded, exploded);
   g_device_scale_factor_for_testing = 0.0;
   return rv;
 }
 #endif
 
 }  // namespace content