Change most uses of Pickle to base::Pickle

components/sessions/session_service_commands.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/sessions/session_service_commands.h"
 
 #include <vector>
 
 #include "base/pickle.h"
 #include "components/sessions/base_session_service_commands.h"
@@ skipping 523 matching lines @@
                 &tab_id,
                 &user_agent_override)) {
           return true;
         }
 
         GetTab(tab_id, tabs)->user_agent_override.swap(user_agent_override);
         break;
       }
 
       case kCommandSessionStorageAssociated: {
-        scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
+        scoped_ptr<base::Pickle> command_pickle(command->PayloadAsPickle());
         SessionID::id_type command_tab_id;
         std::string session_storage_persistent_id;
-        PickleIterator iter(*command_pickle.get());
+        base::PickleIterator iter(*command_pickle.get());
         if (!iter.ReadInt(&command_tab_id) ||
             !iter.ReadString(&session_storage_persistent_id))
           return true;
         // Associate the session storage back.
         GetTab(command_tab_id, tabs)->session_storage_persistent_id =
             session_storage_persistent_id;
         break;
       }
 
       case kCommandSetActiveWindow: {
@@ skipping 140 matching lines @@
   payload.pinned_state = is_pinned;
   scoped_ptr<SessionCommand> command(
       new SessionCommand(kCommandSetPinnedState, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 scoped_ptr<SessionCommand> CreateSessionStorageAssociatedCommand(
     const SessionID& tab_id,
     const std::string& session_storage_persistent_id) {
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(tab_id.id());
   pickle.WriteString(session_storage_persistent_id);
   return scoped_ptr<SessionCommand>(
       new SessionCommand(kCommandSessionStorageAssociated, pickle));
 }
 
 scoped_ptr<SessionCommand> CreateSetActiveWindowCommand(
     const SessionID& window_id) {
   ActiveWindowPayload payload = 0;
   payload = window_id.id();
@@ skipping 80 matching lines @@
   if ((*command)->id() != kCommandUpdateTabNavigation &&
       (*command)->id() != kCommandSetActiveWindow) {
     return false;
   }
   for (ScopedVector<SessionCommand>::const_reverse_iterator i =
            base_session_service->pending_commands().rbegin();
        i != base_session_service->pending_commands().rend(); ++i) {
     SessionCommand* existing_command = *i;
     if ((*command)->id() == kCommandUpdateTabNavigation &&
         existing_command->id() == kCommandUpdateTabNavigation) {
-      scoped_ptr<Pickle> command_pickle((*command)->PayloadAsPickle());
-      PickleIterator iterator(*command_pickle);
+      scoped_ptr<base::Pickle> command_pickle((*command)->PayloadAsPickle());
+      base::PickleIterator iterator(*command_pickle);
       SessionID::id_type command_tab_id;
       int command_nav_index;
       if (!iterator.ReadInt(&command_tab_id) ||
           !iterator.ReadInt(&command_nav_index)) {
         return false;
       }
       SessionID::id_type existing_tab_id;
       int existing_nav_index;
       {
         // Creating a pickle like this means the Pickle references the data from
         // the command. Make sure we delete the pickle before the command, else
         // the pickle references deleted memory.
-        scoped_ptr<Pickle> existing_pickle(existing_command->PayloadAsPickle());
-        iterator = PickleIterator(*existing_pickle);
+        scoped_ptr<base::Pickle> existing_pickle(
+            existing_command->PayloadAsPickle());
+        iterator = base::PickleIterator(*existing_pickle);
         if (!iterator.ReadInt(&existing_tab_id) ||
             !iterator.ReadInt(&existing_nav_index)) {
           return false;
         }
       }
       if (existing_tab_id == command_tab_id &&
           existing_nav_index == command_nav_index) {
         // existing_command is an update for the same tab/index pair. Replace
         // it with the new one. We need to add to the end of the list just in
         // case there is a prune command after the update command.
@@ skipping 28 matching lines @@
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
   STLDeleteValues(&tabs);
   // Don't delete contents of windows, that is done by the caller as all
   // valid windows are added to valid_windows.
 }
 
 }  // namespace sessions