Change most uses of Pickle to base::Pickle

content/common/input/input_param_traits_unittest.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/input/input_param_traits.h"
 
 #include "content/common/input/input_event.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_drag_gesture_params.h"
@@ skipping 90 matching lines @@
                 SyntheticTapGestureParams::Cast(b->gesture_params()));
         break;
     }
   }
 
   static void Verify(const InputEvents& events_in) {
     IPC::Message msg;
     IPC::ParamTraits<InputEvents>::Write(&msg, events_in);
 
     InputEvents events_out;
-    PickleIterator iter(msg);
+    base::PickleIterator iter(msg);
     EXPECT_TRUE(IPC::ParamTraits<InputEvents>::Read(&msg, &iter, &events_out));
 
     Compare(&events_in, &events_out);
 
     // Perform a sanity check that logging doesn't explode.
     std::string events_in_string;
     IPC::ParamTraits<InputEvents>::Log(events_in, &events_in_string);
     std::string events_out_string;
     IPC::ParamTraits<InputEvents>::Log(events_out, &events_out_string);
     ASSERT_FALSE(events_in_string.empty());
     EXPECT_EQ(events_in_string, events_out_string);
   }
 
   static void Verify(const SyntheticGesturePacket& packet_in) {
     IPC::Message msg;
     IPC::ParamTraits<SyntheticGesturePacket>::Write(&msg, packet_in);
 
     SyntheticGesturePacket packet_out;
-    PickleIterator iter(msg);
+    base::PickleIterator iter(msg);
     EXPECT_TRUE(IPC::ParamTraits<SyntheticGesturePacket>::Read(&msg, &iter,
                                                                &packet_out));
 
     Compare(&packet_in, &packet_out);
 
     // Perform a sanity check that logging doesn't explode.
     std::string packet_in_string;
     IPC::ParamTraits<SyntheticGesturePacket>::Log(packet_in, &packet_in_string);
     std::string packet_out_string;
     IPC::ParamTraits<SyntheticGesturePacket>::Log(packet_out,
                                                   &packet_out_string);
     ASSERT_FALSE(packet_in_string.empty());
     EXPECT_EQ(packet_in_string, packet_out_string);
   }
 };
 
 TEST_F(InputParamTraitsTest, UninitializedEvents) {
   InputEvent event;
 
   IPC::Message msg;
   IPC::WriteParam(&msg, event);
 
   InputEvent event_out;
-  PickleIterator iter(msg);
+  base::PickleIterator iter(msg);
   EXPECT_FALSE(IPC::ReadParam(&msg, &iter, &event_out));
 }
 
 TEST_F(InputParamTraitsTest, InitializedEvents) {
   InputEvents events;
 
   ui::LatencyInfo latency;
 
   blink::WebKeyboardEvent key_event;
   key_event.type = blink::WebInputEvent::RawKeyDown;
@@ skipping 25 matching lines @@
 
   Verify(events);
 }
 
 TEST_F(InputParamTraitsTest, InvalidSyntheticGestureParams) {
   IPC::Message msg;
   // Write invalid value for SyntheticGestureParams::GestureType.
   WriteParam(&msg, -3);
 
   SyntheticGesturePacket packet_out;
-  PickleIterator iter(msg);
+  base::PickleIterator iter(msg);
   ASSERT_FALSE(
       IPC::ParamTraits<SyntheticGesturePacket>::Read(&msg, &iter, &packet_out));
 }
 
 TEST_F(InputParamTraitsTest, SyntheticSmoothScrollGestureParams) {
   scoped_ptr<SyntheticSmoothScrollGestureParams> gesture_params(
       new SyntheticSmoothScrollGestureParams);
   gesture_params->gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   gesture_params->anchor.SetPoint(234, 345);
   gesture_params->distances.push_back(gfx::Vector2d(123, -789));
@@ skipping 32 matching lines @@
   ASSERT_EQ(SyntheticGestureParams::TAP_GESTURE,
             gesture_params->GetGestureType());
   SyntheticGesturePacket packet_in;
   packet_in.set_gesture_params(gesture_params.Pass());
 
   Verify(packet_in);
 }
 
 }  // namespace
 }  // namespace content