Remove deprecated methods from Pickle.

components/bookmarks/browser/bookmark_node_data.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_node_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/pickle.h"
@@ skipping 39 matching lines @@
   }
   if (!is_url) {
     pickle->WriteSizeT(children.size());
     for (std::vector<Element>::const_iterator i = children.begin();
          i != children.end(); ++i) {
       i->WriteToPickle(pickle);
     }
   }
 }
 
-bool BookmarkNodeData::Element::ReadFromPickle(Pickle* pickle,
-                                               PickleIterator* iterator) {
+bool BookmarkNodeData::Element::ReadFromPickle(PickleIterator* iterator) {
   std::string url_spec;
-  if (!pickle->ReadBool(iterator, &is_url) ||
-      !pickle->ReadString(iterator, &url_spec) ||
-      !pickle->ReadString16(iterator, &title) ||
-      !pickle->ReadInt64(iterator, &id_)) {
+  if (!iterator->ReadBool(&is_url) ||
+      !iterator->ReadString(&url_spec) ||
+      !iterator->ReadString16(&title) ||
+      !iterator->ReadInt64(&id_)) {
     return false;
   }
   url = GURL(url_spec);
   date_added = base::Time();
   date_folder_modified = base::Time();
   meta_info_map.clear();
   size_t meta_field_count;
-  if (!pickle->ReadSizeT(iterator, &meta_field_count))
+  if (!iterator->ReadSizeT(&meta_field_count))
     return false;
   for (size_t i = 0; i < meta_field_count; ++i) {
     std::string key;
     std::string value;
-    if (!pickle->ReadString(iterator, &key) ||
-        !pickle->ReadString(iterator, &value)) {
+    if (!iterator->ReadString(&key) ||
+        !iterator->ReadString(&value)) {
       return false;
     }
     meta_info_map[key] = value;
   }
   children.clear();
   if (!is_url) {
     size_t children_count;
-    if (!pickle->ReadSizeT(iterator, &children_count))
+    if (!iterator->ReadSizeT(&children_count))
       return false;
     children.reserve(children_count);
     for (size_t i = 0; i < children_count; ++i) {
       children.push_back(Element());
-      if (!children.back().ReadFromPickle(pickle, iterator))
+      if (!children.back().ReadFromPickle(iterator))
         return false;
     }
   }
   return true;
 }
 
 // BookmarkNodeData -----------------------------------------------------------
 
 BookmarkNodeData::BookmarkNodeData() {
 }
@@ skipping 134 matching lines @@
   pickle->WriteSizeT(elements.size());
 
   for (size_t i = 0; i < elements.size(); ++i)
     elements[i].WriteToPickle(pickle);
 }
 
 bool BookmarkNodeData::ReadFromPickle(Pickle* pickle) {
   PickleIterator data_iterator(*pickle);
   size_t element_count;
   if (profile_path_.ReadFromPickle(&data_iterator) &&
-      pickle->ReadSizeT(&data_iterator, &element_count)) {
+      data_iterator.ReadSizeT(&element_count)) {
     std::vector<Element> tmp_elements;
     tmp_elements.resize(element_count);
     for (size_t i = 0; i < element_count; ++i) {
-      if (!tmp_elements[i].ReadFromPickle(pickle, &data_iterator)) {
+      if (!tmp_elements[i].ReadFromPickle(&data_iterator)) {
         return false;
       }
     }
     elements.swap(tmp_elements);
   }
 
   return true;
 }
 
 std::vector<const BookmarkNode*> BookmarkNodeData::GetNodes(
@@ skipping 33 matching lines @@
   profile_path_ = profile_path;
 }
 
 bool BookmarkNodeData::IsFromProfilePath(
     const base::FilePath& profile_path) const {
   // An empty path means the data is not associated with any profile.
   return !profile_path_.empty() && profile_path_ == profile_path;
 }
 
 }  // namespace bookmarks