Change most uses of Pickle to base::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 19 matching lines @@
       id_(node->id()) {
   if (node->GetMetaInfoMap())
     meta_info_map = *node->GetMetaInfoMap();
   for (int i = 0; i < node->child_count(); ++i)
     children.push_back(Element(node->GetChild(i)));
 }
 
 BookmarkNodeData::Element::~Element() {
 }
 
-void BookmarkNodeData::Element::WriteToPickle(Pickle* pickle) const {
+void BookmarkNodeData::Element::WriteToPickle(base::Pickle* pickle) const {
   pickle->WriteBool(is_url);
   pickle->WriteString(url.spec());
   pickle->WriteString16(title);
   pickle->WriteInt64(id_);
   pickle->WriteSizeT(meta_info_map.size());
   for (BookmarkNode::MetaInfoMap::const_iterator it = meta_info_map.begin();
       it != meta_info_map.end(); ++it) {
     pickle->WriteString(it->first);
     pickle->WriteString(it->second);
   }
   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(PickleIterator* iterator) {
+bool BookmarkNodeData::Element::ReadFromPickle(base::PickleIterator* iterator) {
   std::string url_spec;
   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();
@@ skipping 116 matching lines @@
         const base::string16 title = elements[i].title;
         text += title;
       } else {
         const base::string16 url = base::UTF8ToUTF16(elements[i].url.spec());
         text += url;
       }
     }
     scw.WriteText(text);
   }
 
-  Pickle pickle;
+  base::Pickle pickle;
   WriteToPickle(base::FilePath(), &pickle);
   scw.WritePickledData(pickle,
                        ui::Clipboard::GetFormatType(kClipboardFormatString));
 }
 
 bool BookmarkNodeData::ReadFromClipboard(ui::ClipboardType type) {
   DCHECK_EQ(type, ui::CLIPBOARD_TYPE_COPY_PASTE);
   std::string data;
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
   clipboard->ReadData(ui::Clipboard::GetFormatType(kClipboardFormatString),
                       &data);
 
   if (!data.empty()) {
-    Pickle pickle(data.data(), static_cast<int>(data.size()));
+    base::Pickle pickle(data.data(), static_cast<int>(data.size()));
     if (ReadFromPickle(&pickle))
       return true;
   }
 
   base::string16 title;
   std::string url;
   clipboard->ReadBookmark(&title, &url);
   if (!url.empty()) {
     Element element;
     element.is_url = true;
     element.url = GURL(url);
     element.title = title;
 
     elements.clear();
     elements.push_back(element);
     return true;
   }
 
   return false;
 }
 #endif
 
 void BookmarkNodeData::WriteToPickle(const base::FilePath& profile_path,
-                                     Pickle* pickle) const {
+                                     base::Pickle* pickle) const {
   profile_path.WriteToPickle(pickle);
   pickle->WriteSizeT(size());
 
   for (size_t i = 0; i < size(); ++i)
     elements[i].WriteToPickle(pickle);
 }
 
-bool BookmarkNodeData::ReadFromPickle(Pickle* pickle) {
-  PickleIterator data_iterator(*pickle);
+bool BookmarkNodeData::ReadFromPickle(base::Pickle* pickle) {
+  base::PickleIterator data_iterator(*pickle);
   size_t element_count;
   if (profile_path_.ReadFromPickle(&data_iterator) &&
       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(&data_iterator)) {
         return false;
       }
     }
@@ skipping 40 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