Return buffers from StreamParsers in a single unified map

media/filters/frame_processor_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 15 matching lines @@
 #include "media/filters/frame_processor.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::StrictMock;
 using ::testing::Values;
 
 namespace media {
 
 typedef StreamParser::BufferQueue BufferQueue;
-typedef StreamParser::TextBufferQueueMap TextBufferQueueMap;
 typedef StreamParser::TrackId TrackId;
 
 // Used for setting expectations on callbacks. Using a StrictMock also lets us
 // test for missing or extra callbacks.
 class FrameProcessorTestCallbackHelper {
  public:
   FrameProcessorTestCallbackHelper() {}
   virtual ~FrameProcessorTestCallbackHelper() {}
 
   MOCK_METHOD1(PossibleDurationIncrease, void(base::TimeDelta new_duration));
@@ skipping 98 matching lines @@
       }
 
       buffer->set_duration(frame_duration_);
       buffers.push_back(buffer);
     }
     return buffers;
   }
 
   void ProcessFrames(const std::string& audio_timestamps,
                      const std::string& video_timestamps) {
+    StreamParser::BufferQueueMap buffer_queue_map;
+    const auto& audio_buffers =
+        StringToBufferQueue(audio_timestamps, audio_id_, DemuxerStream::AUDIO);
+    if (!audio_buffers.empty())
+      buffer_queue_map.insert(std::make_pair(audio_id_, audio_buffers));
+    const auto& video_buffers =
+        StringToBufferQueue(video_timestamps, video_id_, DemuxerStream::VIDEO);
+    if (!video_buffers.empty())
+      buffer_queue_map.insert(std::make_pair(video_id_, video_buffers));
     ASSERT_TRUE(frame_processor_->ProcessFrames(
-        StringToBufferQueue(audio_timestamps, audio_id_, DemuxerStream::AUDIO),
-        StringToBufferQueue(video_timestamps, video_id_, DemuxerStream::VIDEO),
-        empty_text_buffers_, append_window_start_, append_window_end_,
+        buffer_queue_map, append_window_start_, append_window_end_,
         &timestamp_offset_));
   }
 
   void CheckExpectedRangesByTimestamp(ChunkDemuxerStream* stream,
                                       const std::string& expected) {
     // Note, DemuxerStream::TEXT streams return [0,duration (==infinity here))
     Ranges<base::TimeDelta> r = stream->GetBufferedRanges(kInfiniteDuration);
 
     std::stringstream ss;
     ss << "{ ";
@@ skipping 94 matching lines @@
   std::unique_ptr<FrameProcessor> frame_processor_;
   base::TimeDelta append_window_start_;
   base::TimeDelta append_window_end_;
   base::TimeDelta timestamp_offset_;
   base::TimeDelta frame_duration_;
   std::unique_ptr<ChunkDemuxerStream> audio_;
   std::unique_ptr<ChunkDemuxerStream> video_;
   const TrackId audio_id_;
   const TrackId video_id_;
   const BufferQueue empty_queue_;
-  const TextBufferQueueMap empty_text_buffers_;
 
   // StoreStatusAndBuffer's most recent result.
   DemuxerStream::Status last_read_status_;
   scoped_refptr<DecoderBuffer> last_read_buffer_;
   bool read_callback_called_;
 
  private:
   void StoreStatusAndBuffer(DemuxerStream::Status status,
                             const scoped_refptr<DecoderBuffer>& buffer) {
     if (status == DemuxerStream::kOk && buffer.get()) {
@@ skipping 37 matching lines @@
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(FrameProcessorTest);
 };
 
 TEST_F(FrameProcessorTest, WrongTypeInAppendedBuffer) {
   AddTestTracks(HAS_AUDIO);
   EXPECT_FALSE(in_coded_frame_group());
 
-  ASSERT_FALSE(frame_processor_->ProcessFrames(
-      StringToBufferQueue("0K", audio_id_, DemuxerStream::VIDEO), empty_queue_,
-      empty_text_buffers_, append_window_start_, append_window_end_,
-      &timestamp_offset_));
+  StreamParser::BufferQueueMap buffer_queue_map;
+  const auto& audio_buffers =
+      StringToBufferQueue("0K", audio_id_, DemuxerStream::VIDEO);
+  buffer_queue_map.insert(std::make_pair(audio_id_, audio_buffers));
+  ASSERT_FALSE(
+      frame_processor_->ProcessFrames(buffer_queue_map, append_window_start_,
+                                      append_window_end_, &timestamp_offset_));
   EXPECT_FALSE(in_coded_frame_group());
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ }");
   CheckReadStalls(audio_.get());
 }
 
 TEST_F(FrameProcessorTest, NonMonotonicallyIncreasingTimestampInOneCall) {
   AddTestTracks(HAS_AUDIO);
 
-  ASSERT_FALSE(frame_processor_->ProcessFrames(
-      StringToBufferQueue("10K 0K", audio_id_, DemuxerStream::AUDIO),
-      empty_queue_, empty_text_buffers_, append_window_start_,
-      append_window_end_, &timestamp_offset_));
+  StreamParser::BufferQueueMap buffer_queue_map;
+  const auto& audio_buffers =
+      StringToBufferQueue("10K 0K", audio_id_, DemuxerStream::AUDIO);
+  buffer_queue_map.insert(std::make_pair(audio_id_, audio_buffers));
+  ASSERT_FALSE(
+      frame_processor_->ProcessFrames(buffer_queue_map, append_window_start_,
+                                      append_window_end_, &timestamp_offset_));
   EXPECT_FALSE(in_coded_frame_group());
   EXPECT_EQ(base::TimeDelta(), timestamp_offset_);
   CheckExpectedRangesByTimestamp(audio_.get(), "{ }");
   CheckReadStalls(audio_.get());
 }
 
 TEST_P(FrameProcessorTest, AudioOnly_SingleFrame) {
   // Tests A: P(A) -> (a)
   InSequence s;
   AddTestTracks(HAS_AUDIO);
@@ skipping 530 matching lines @@
   StreamParserBuffer* last_read_parser_buffer =
       static_cast<StreamParserBuffer*>(last_read_buffer_.get());
   ASSERT_EQ(base::TimeDelta::FromMilliseconds(0),
             last_read_parser_buffer->preroll_buffer()->duration());
 }
 
 INSTANTIATE_TEST_CASE_P(SequenceMode, FrameProcessorTest, Values(true));
 INSTANTIATE_TEST_CASE_P(SegmentsMode, FrameProcessorTest, Values(false));
 
 }  // namespace media