Remove stl_util's deletion functions from media/.

media/cast/test/end2end_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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 239 matching lines @@
   }
 
   void AddExpectedResult(const AudioBus& audio_bus,
                          const base::TimeTicks& playout_time) {
     std::unique_ptr<ExpectedAudioFrame> expected_audio_frame(
         new ExpectedAudioFrame());
     expected_audio_frame->audio_bus =
         AudioBus::Create(audio_bus.channels(), audio_bus.frames());
     audio_bus.CopyTo(expected_audio_frame->audio_bus.get());
     expected_audio_frame->playout_time = playout_time;
-    expected_frames_.push_back(expected_audio_frame.release());
+    expected_frames_.push_back(std::move(expected_audio_frame));
   }
 
   void IgnoreAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                         const base::TimeTicks& playout_time,
                         bool is_continuous) {
     ++num_called_;
   }
 
   void CheckAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                        const base::TimeTicks& playout_time,
                        bool is_continuous) {
     ++num_called_;
 
     ASSERT_TRUE(audio_bus);
     ASSERT_FALSE(expected_frames_.empty());
-    const std::unique_ptr<ExpectedAudioFrame> expected_audio_frame(
-        expected_frames_.front());
+    const std::unique_ptr<ExpectedAudioFrame> expected_audio_frame =
+        std::move(expected_frames_.front());
     expected_frames_.pop_front();
 
     EXPECT_EQ(audio_bus->channels(), kAudioChannels);
     EXPECT_EQ(audio_bus->frames(), expected_audio_frame->audio_bus->frames());
     for (int ch = 0; ch < audio_bus->channels(); ++ch) {
       EXPECT_NEAR(CountZeroCrossings(
                       expected_audio_frame->audio_bus->channel(ch),
                       expected_audio_frame->audio_bus->frames()),
                   CountZeroCrossings(audio_bus->channel(ch),
                                      audio_bus->frames()),
                   1);
     }
 
     EXPECT_NEAR(
         (playout_time - expected_audio_frame->playout_time).InMillisecondsF(),
         0.0,
         kMaxAllowedPlayoutErrorMs);
     VLOG_IF(1, !last_playout_time_.is_null())
         << "Audio frame playout time delta (compared to last frame) is "
         << (playout_time - last_playout_time_).InMicroseconds() << " usec.";
     last_playout_time_ = playout_time;
 
     EXPECT_TRUE(is_continuous);
   }
 
   int number_times_called() const { return num_called_; }
 
  protected:
   virtual ~TestReceiverAudioCallback() {
-    base::STLDeleteElements(&expected_frames_);
   }
 
  private:
   friend class base::RefCountedThreadSafe<TestReceiverAudioCallback>;
 
   int num_called_;
   int expected_sampling_frequency_;
-  std::list<ExpectedAudioFrame*> expected_frames_;
+  std::list<std::unique_ptr<ExpectedAudioFrame>> expected_frames_;
   base::TimeTicks last_playout_time_;
 };
 
 // Class that verifies the video frames coming out of the receiver.
 class TestReceiverVideoCallback
     : public base::RefCountedThreadSafe<TestReceiverVideoCallback> {
  public:
   struct ExpectedVideoFrame {
     int frame_number;
     gfx::Size size;
@@ skipping 945 matching lines @@
       EXPECT_EQ(0u, jump);
       jump = i;
     }
   }
   EXPECT_GT(jump, 49u);
   EXPECT_LT(jump, 120u);
 }
 
 }  // namespace cast
 }  // namespace media