Remove ScopedVector from media/base/

media/base/text_renderer_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 "media/base/text_renderer.h"
 
 #include <stddef.h>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"

[xhwang, 2017/05/10 17:24:48]

#include "base/memory/ptr_util.h"

[Chandan, 2017/05/11 06:04:04]

Done.

-#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/fake_text_track_stream.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/webvtt_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 44 matching lines @@
   void Destroy() {
     text_renderer_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void AddTextTrack(TextKind kind,
                     const std::string& name,
                     const std::string& language,
                     bool expect_read) {
     const size_t idx = text_track_streams_.size();
-    text_track_streams_.push_back(new FakeTextTrackStream);
+    text_track_streams_.push_back(base::MakeUnique<FakeTextTrackStream>());
 
     if (expect_read)
       ExpectRead(idx);
 
     const TextTrackConfig config(kind, name, language, std::string());
-    text_renderer_->AddTextStream(text_track_streams_.back(), config);
+    text_renderer_->AddTextStream(text_track_streams_.back().get(), config);
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(text_tracks_.size(), text_track_streams_.size());
     FakeTextTrack* const text_track = text_tracks_.back();
     EXPECT_TRUE(text_track);
     EXPECT_TRUE(text_track->config_.Matches(config));
   }
 
   void OnAddTextTrack(const TextTrackConfig& config,
                       const AddTextTrackDoneCB& done_cb) {
     base::Closure destroy_cb =
         base::Bind(&TextRendererTest::OnDestroyTextTrack,
                    base::Unretained(this),
                    text_tracks_.size());
     // Text track objects are owned by the text renderer, but we cache them
     // here so we can inspect them.  They get removed from our cache when the
     // text renderer deallocates them.
     text_tracks_.push_back(new FakeTextTrack(destroy_cb, config));
     std::unique_ptr<TextTrack> text_track(text_tracks_.back());
     done_cb.Run(std::move(text_track));
   }
 
   void RemoveTextTrack(unsigned idx) {
-    FakeTextTrackStream* const stream = text_track_streams_[idx];
+    FakeTextTrackStream* const stream = text_track_streams_[idx].get();
     text_renderer_->RemoveTextStream(stream);
     EXPECT_FALSE(text_tracks_[idx]);
   }
 
   void SatisfyPendingReads(const base::TimeDelta& start,
                            const base::TimeDelta& duration,
                            const std::string& id,
                            const std::string& content,
                            const std::string& settings) {
     for (TextTrackStreams::iterator itr = text_track_streams_.begin();
          itr != text_track_streams_.end(); ++itr) {
       (*itr)->SatisfyPendingRead(start, duration, id, content, settings);
     }
   }
 
   void AbortPendingRead(unsigned idx) {
-    FakeTextTrackStream* const stream = text_track_streams_[idx];
+    FakeTextTrackStream* const stream = text_track_streams_[idx].get();
     stream->AbortPendingRead();
     base::RunLoop().RunUntilIdle();
   }
 
   void AbortPendingReads() {
     for (size_t idx = 0; idx < text_track_streams_.size(); ++idx) {
       AbortPendingRead(idx);
     }
   }
 
   void SendEosNotification(unsigned idx) {
-    FakeTextTrackStream* const stream = text_track_streams_[idx];
+    FakeTextTrackStream* const stream = text_track_streams_[idx].get();
     stream->SendEosNotification();
     base::RunLoop().RunUntilIdle();
   }
 
   void SendEosNotifications() {
     for (size_t idx = 0; idx < text_track_streams_.size(); ++idx) {
       SendEosNotification(idx);
     }
   }
 
   void SendCue(unsigned idx, bool expect_cue) {
-    FakeTextTrackStream* const text_stream = text_track_streams_[idx];
+    FakeTextTrackStream* const text_stream = text_track_streams_[idx].get();
 
     const base::TimeDelta start;
     const base::TimeDelta duration = base::TimeDelta::FromSeconds(42);
     const std::string id = "id";
     const std::string content = "subtitle";
     const std::string settings;
 
     if (expect_cue) {
       FakeTextTrack* const text_track = text_tracks_[idx];
       EXPECT_CALL(*text_track, addWebVTTCue(start,
@@ skipping 27 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void Flush() {
     EXPECT_CALL(*this, OnFlush());
     text_renderer_->Flush(base::Bind(&TextRendererTest::OnFlush,
                                      base::Unretained(this)));
   }
 
   void ExpectRead(size_t idx) {
-    FakeTextTrackStream* const stream = text_track_streams_[idx];
+    FakeTextTrackStream* const stream = text_track_streams_[idx].get();
     EXPECT_CALL(*stream, OnRead());
   }
 
   MOCK_METHOD0(OnEnd, void());
   MOCK_METHOD0(OnPause, void());
   MOCK_METHOD0(OnFlush, void());
 
   base::MessageLoop message_loop_;
 
-  typedef ScopedVector<FakeTextTrackStream> TextTrackStreams;
+  typedef std::vector<std::unique_ptr<FakeTextTrackStream>> TextTrackStreams;
   TextTrackStreams text_track_streams_;
 
   typedef std::vector<FakeTextTrack*> TextTracks;
   TextTracks text_tracks_;
 
   std::unique_ptr<TextRenderer> text_renderer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TextRendererTest);
 };
@@ skipping 986 matching lines @@
   Play();
   AbortPendingRead(0);
   RemoveTextTrack(0);
   EXPECT_TRUE(text_renderer_->HasTracks());
   Pause();
   EXPECT_CALL(*this, OnPause());
   SendEosNotification(1);
 }
 
 }  // namespace media