// Copyright 2015 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/muxers/webm_muxer.h"

#include <stddef.h>
#include <stdint.h>
#include <memory>

#include "base/bind.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/test/task_environment.h"
#include "media/base/audio_codecs.h"
#include "media/base/audio_parameters.h"
#include "media/base/channel_layout.h"
#include "media/base/decoder_buffer.h"
#include "media/base/media_tracks.h"
#include "media/base/mock_media_log.h"
#include "media/base/stream_parser.h"
#include "media/base/stream_parser_buffer.h"
#include "media/base/text_track_config.h"
#include "media/base/video_codecs.h"
#include "media/base/video_frame.h"
#include "media/formats/webm/webm_stream_parser.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using ::testing::_;
using ::testing::AllOf;
using ::testing::AnyNumber;
using ::testing::AtLeast;
using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::InSequence;
using ::testing::Mock;
using ::testing::Not;
using ::testing::Pair;
using ::testing::Pointee;
using ::testing::Property;
using ::testing::Return;
using ::testing::Sequence;
using ::testing::TestWithParam;
using ::testing::UnorderedElementsAre;
using ::testing::ValuesIn;
using ::testing::WithArgs;

namespace media {

struct TestParams {
  VideoCodec video_codec;
  AudioCodec audio_codec;
  size_t num_video_tracks;
  size_t num_audio_tracks;
};

class WebmMuxerTest : public TestWithParam<TestParams> {
 public:
  WebmMuxerTest()
      : webm_muxer_(std::make_unique<WebmMuxer>(
            GetParam().audio_codec,
            GetParam().num_video_tracks,
            GetParam().num_audio_tracks,
            base::BindRepeating(&WebmMuxerTest::WriteCallback,
                                base::Unretained(this)))) {
    EXPECT_EQ(webm_muxer_->Position(), 0);
    const mkvmuxer::int64 kRandomNewPosition = 333;
    EXPECT_EQ(webm_muxer_->Position(kRandomNewPosition), -1);
    EXPECT_FALSE(webm_muxer_->Seekable());
  }

  MOCK_METHOD(void, WriteCallback, (base::StringPiece));

  void SaveEncodedDataLen(const base::StringPiece& encoded_data) {
    last_encoded_length_ = encoded_data.size();
    accumulated_position_ += encoded_data.size();
  }

  mkvmuxer::int64 GetWebmMuxerPosition() const {
    return webm_muxer_->Position();
  }

  mkvmuxer::Segment::Mode GetWebmSegmentMode() const {
    return webm_muxer_->segment_.mode();
  }

  mkvmuxer::int32 WebmMuxerWrite(const void* buf, mkvmuxer::uint32 len) {
    return webm_muxer_->Write(buf, len);
  }

  WebmMuxer::VideoParameters GetVideoParameters(
      scoped_refptr<VideoFrame> frame) {
    WebmMuxer::VideoParameters parameters(frame);
    parameters.codec = GetParam().video_codec;
    return parameters;
  }

  mkvmuxer::Colour* GetVideoTrackColor() const {
    mkvmuxer::VideoTrack* const video_track =
        reinterpret_cast<mkvmuxer::VideoTrack*>(
            webm_muxer_->segment_.GetTrackByNumber(
                webm_muxer_->video_track_index_));
    return video_track->colour();
  }

  std::unique_ptr<WebmMuxer> webm_muxer_;

  size_t last_encoded_length_ = 0;
  int64_t accumulated_position_ = 0;

 private:
  DISALLOW_COPY_AND_ASSIGN(WebmMuxerTest);
};

// Checks that the WriteCallback is called with appropriate params when
// WebmMuxer::Write() method is called.
TEST_P(WebmMuxerTest, Write) {
  const base::StringPiece encoded_data("abcdefghijklmnopqrstuvwxyz");

  EXPECT_CALL(*this, WriteCallback(encoded_data));
  WebmMuxerWrite(encoded_data.data(), encoded_data.size());

  EXPECT_EQ(GetWebmMuxerPosition(), static_cast<int64_t>(encoded_data.size()));
}

TEST_P(WebmMuxerTest,
       HandlesMuxerErrorInPassingEncodedFramesWithAudioThenVideo) {
  auto video_params =
      GetVideoParameters(VideoFrame::CreateBlackFrame(gfx::Size(160, 80)));
  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
  media::AudioParameters audio_params(
      media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
      media::CHANNEL_LAYOUT_MONO, /*sample_rate=*/48000,
      /*frames_per_buffer=*/480);
  // Force an error in libwebm and expect OnEncodedVideo to fail.
  webm_muxer_->ForceOneLibWebmErrorForTesting();
  base::TimeTicks now = base::TimeTicks::Now();
  bool audio_success =
      !GetParam().num_audio_tracks ||
      webm_muxer_->OnEncodedAudio(audio_params, encoded_data, now);
  bool video_success =
      !GetParam().num_video_tracks ||
      webm_muxer_->OnEncodedVideo(video_params, encoded_data, std::string(),
                                  now + base::TimeDelta::FromMilliseconds(1),
                                  /*is_key_frame=*/true);
  EXPECT_FALSE(audio_success && video_success);
}

TEST_P(WebmMuxerTest,
       HandlesMuxerErrorInPassingEncodedFramesWithVideoThenAudio) {
  auto video_params =
      GetVideoParameters(VideoFrame::CreateBlackFrame(gfx::Size(160, 80)));
  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
  media::AudioParameters audio_params(
      media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
      media::CHANNEL_LAYOUT_MONO, /*sample_rate=*/48000,
      /*frames_per_buffer=*/480);
  // Force an error in libwebm and expect OnEncodedVideo to fail.
  webm_muxer_->ForceOneLibWebmErrorForTesting();
  base::TimeTicks now = base::TimeTicks::Now();
  bool video_success =
      !GetParam().num_video_tracks ||
      webm_muxer_->OnEncodedVideo(video_params, encoded_data, std::string(),
                                  now + base::TimeDelta::FromMilliseconds(1),
                                  /*is_key_frame=*/true);
  bool audio_success =
      !GetParam().num_audio_tracks ||
      webm_muxer_->OnEncodedAudio(audio_params, encoded_data, now);
  EXPECT_FALSE(audio_success && video_success);
}

// This test sends two frames and checks that the WriteCallback is called with
// appropriate params in both cases.
TEST_P(WebmMuxerTest, OnEncodedVideoTwoFrames) {
  if (GetParam().num_audio_tracks > 0)
    return;

  const gfx::Size frame_size(160, 80);
  const scoped_refptr<VideoFrame> video_frame =
      VideoFrame::CreateBlackFrame(frame_size);
  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");

  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_data, std::string(),
      base::TimeTicks::Now(), false /* keyframe */));

  // First time around WriteCallback() is pinged a number of times to write the
  // Matroska header, but at the end it dumps |encoded_data|.
  EXPECT_EQ(last_encoded_length_, encoded_data.size());
  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
  EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);

  const int64_t begin_of_second_block = accumulated_position_;
  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_data, std::string(),
      base::TimeTicks::Now(), false /* keyframe */));

  // The second time around the callbacks should include a SimpleBlock header,
  // namely the track index, a timestamp and a flags byte, for a total of 6B.
  EXPECT_EQ(last_encoded_length_, encoded_data.size());
  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  const uint32_t kSimpleBlockSize = 6u;
  EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kSimpleBlockSize +
                                 encoded_data.size()),
            accumulated_position_);
}

// This test sends two transparent frames and checks that the WriteCallback is
// called with appropriate params in both cases.
TEST_P(WebmMuxerTest, OnEncodedVideoTwoAlphaFrames) {
  if (GetParam().num_audio_tracks > 0)
    return;

  const gfx::Size frame_size(160, 80);
  const scoped_refptr<VideoFrame> video_frame =
      VideoFrame::CreateTransparentFrame(frame_size);
  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
  const std::string alpha_encoded_data("ijklmnopqrstuvwxyz");

  InSequence s;
  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_data, alpha_encoded_data,
      base::TimeTicks::Now(), true /* keyframe */));

  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
  EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);

  const int64_t begin_of_second_block = accumulated_position_;
  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_data, alpha_encoded_data,
      base::TimeTicks::Now(), false /* keyframe */));

  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  // Alpha introduces additional elements to be written, see
  // mkvmuxer::WriteBlock().
  const uint32_t kBlockGroupSize = 2u;
  const uint32_t kSimpleBlockSize = 6u;
  const uint32_t kAdditionsSize = 13u;
  EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kBlockGroupSize +
                                 kSimpleBlockSize + encoded_data.size() +
                                 kAdditionsSize + alpha_encoded_data.size()),
            accumulated_position_);
}

TEST_P(WebmMuxerTest, OnEncodedAudioTwoFrames) {
  if (GetParam().num_video_tracks > 0)
    return;

  const int sample_rate = 48000;
  const int frames_per_buffer = 480;
  media::AudioParameters audio_params(
      media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
      media::CHANNEL_LAYOUT_MONO, sample_rate, frames_per_buffer);

  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");

  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedAudio(audio_params, encoded_data,
                                          base::TimeTicks::Now()));

  // First time around WriteCallback() is pinged a number of times to write the
  // Matroska header, but at the end it dumps |encoded_data|.
  EXPECT_EQ(last_encoded_length_, encoded_data.size());
  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
  EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);

  const int64_t begin_of_second_block = accumulated_position_;
  EXPECT_CALL(*this, WriteCallback(_))
      .Times(AtLeast(1))
      .WillRepeatedly(
          WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
  EXPECT_TRUE(webm_muxer_->OnEncodedAudio(audio_params, encoded_data,
                                          base::TimeTicks::Now()));

  // The second time around the callbacks should include a SimpleBlock header,
  // namely the track index, a timestamp and a flags byte, for a total of 6B.
  EXPECT_EQ(last_encoded_length_, encoded_data.size());
  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
  const uint32_t kSimpleBlockSize = 6u;
  EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kSimpleBlockSize +
                                 encoded_data.size()),
            accumulated_position_);
}

TEST_P(WebmMuxerTest, ColorSpaceREC709IsPropagatedToTrack) {
  WebmMuxer::VideoParameters params(gfx::Size(1, 1), 0, media::kCodecVP9,
                                    gfx::ColorSpace::CreateREC709());
  webm_muxer_->OnEncodedVideo(params, "abab", {}, base::TimeTicks::Now(),
                              true /* keyframe */);
  mkvmuxer::Colour* colour = GetVideoTrackColor();
  EXPECT_EQ(colour->primaries(), mkvmuxer::Colour::kIturBt709P);
  EXPECT_EQ(colour->transfer_characteristics(), mkvmuxer::Colour::kIturBt709Tc);
  EXPECT_EQ(colour->matrix_coefficients(), mkvmuxer::Colour::kBt709);
  EXPECT_EQ(colour->range(), mkvmuxer::Colour::kBroadcastRange);
}

TEST_P(WebmMuxerTest, ColorSpaceExtendedSRGBIsPropagatedToTrack) {
  WebmMuxer::VideoParameters params(
      gfx::Size(1, 1), 0, media::kCodecVP9,
      gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT709,
                      gfx::ColorSpace::TransferID::IEC61966_2_1,
                      gfx::ColorSpace::MatrixID::BT709,
                      gfx::ColorSpace::RangeID::LIMITED));
  webm_muxer_->OnEncodedVideo(params, "banana", {}, base::TimeTicks::Now(),
                              true /* keyframe */);
  mkvmuxer::Colour* colour = GetVideoTrackColor();
  EXPECT_EQ(colour->primaries(), mkvmuxer::Colour::kIturBt709P);
  EXPECT_EQ(colour->transfer_characteristics(), mkvmuxer::Colour::kIec6196621);
  EXPECT_EQ(colour->matrix_coefficients(), mkvmuxer::Colour::kBt709);
  EXPECT_EQ(colour->range(), mkvmuxer::Colour::kBroadcastRange);
}

TEST_P(WebmMuxerTest, ColorSpaceHDR10IsPropagatedToTrack) {
  WebmMuxer::VideoParameters params(
      gfx::Size(1, 1), 0, media::kCodecVP9,
      gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT2020,
                      gfx::ColorSpace::TransferID::SMPTEST2084,
                      gfx::ColorSpace::MatrixID::BT2020_NCL,
                      gfx::ColorSpace::RangeID::LIMITED));
  webm_muxer_->OnEncodedVideo(params, "cafebabe", {}, base::TimeTicks::Now(),
                              true /* keyframe */);
  mkvmuxer::Colour* colour = GetVideoTrackColor();
  EXPECT_EQ(colour->primaries(), mkvmuxer::Colour::kIturBt2020);
  EXPECT_EQ(colour->transfer_characteristics(), mkvmuxer::Colour::kSmpteSt2084);
  EXPECT_EQ(colour->matrix_coefficients(),
            mkvmuxer::Colour::kBt2020NonConstantLuminance);
  EXPECT_EQ(colour->range(), mkvmuxer::Colour::kBroadcastRange);
}

TEST_P(WebmMuxerTest, ColorSpaceFullRangeHDR10IsPropagatedToTrack) {
  WebmMuxer::VideoParameters params(
      gfx::Size(1, 1), 0, media::kCodecVP9,
      gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT2020,
                      gfx::ColorSpace::TransferID::SMPTEST2084,
                      gfx::ColorSpace::MatrixID::BT2020_NCL,
                      gfx::ColorSpace::RangeID::FULL));
  webm_muxer_->OnEncodedVideo(params, "beatles", {}, base::TimeTicks::Now(),
                              true /* keyframe */);
  mkvmuxer::Colour* colour = GetVideoTrackColor();
  EXPECT_EQ(colour->range(), mkvmuxer::Colour::kFullRange);
}

// This test verifies that when video data comes before audio data, we save the
// encoded video frames and add it to the video track when audio data arrives.
TEST_P(WebmMuxerTest, VideoIsStoredWhileWaitingForAudio) {
  // This test is only relevant if we have both kinds of tracks.
  if (GetParam().num_video_tracks == 0 || GetParam().num_audio_tracks == 0)
    return;

  // First send a video keyframe.
  const gfx::Size frame_size(160, 80);
  const scoped_refptr<VideoFrame> video_frame =
      VideoFrame::CreateBlackFrame(frame_size);
  const std::string encoded_video("thisisanencodedvideopacket");

  // Timestamp: 0 (video origin)
  webm_muxer_->OnEncodedVideo(GetVideoParameters(video_frame), encoded_video,
                              std::string(), base::TimeTicks(),
                              true /* keyframe */);

  // Timestamp: video origin + X
  webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_video, std::string(),
      base::TimeTicks() + base::TimeDelta::FromMilliseconds(1),
      false /* keyframe */);

  // Timestamp: video origin + X + Y
  webm_muxer_->OnEncodedVideo(
      GetVideoParameters(video_frame), encoded_video, std::string(),
      base::TimeTicks() + base::TimeDelta::FromMilliseconds(2),
      false /* keyframe */);

  const int sample_rate = 48000;
  const int frames_per_buffer = 480;
  media::AudioParameters audio_params(
      media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
      media::CHANNEL_LAYOUT_MONO, sample_rate, frames_per_buffer);
  const std::string encoded_audio("thisisanencodedaudiopacket");

  // Timestamped frames should come as:
  // [video origin, audio origin, video origin + X, video origin + X + Y]
  Sequence s;
  EXPECT_CALL(*this, WriteCallback(Eq(encoded_video))).Times(1).InSequence(s);
  EXPECT_CALL(*this, WriteCallback(Eq(encoded_audio))).Times(1).InSequence(s);
  EXPECT_CALL(*this, WriteCallback(Eq(encoded_video))).Times(1).InSequence(s);
  EXPECT_CALL(*this, WriteCallback(Eq(encoded_video))).Times(1).InSequence(s);

  // We'll also get lots of other header-related stuff.
  EXPECT_CALL(*this, WriteCallback(
                         AllOf(Not(Eq(encoded_video)), Not(Eq(encoded_audio)))))
      .Times(AnyNumber());

  // Timestamp: 0 (audio origin)
  webm_muxer_->OnEncodedAudio(
      audio_params, encoded_audio,
      base::TimeTicks() + base::TimeDelta::FromMilliseconds(3));
  webm_muxer_.reset();
}

const TestParams kTestCases[] = {
    {kCodecVP8, kCodecOpus, 1 /* num_video_tracks */, 0 /*num_audio_tracks*/},
    {kCodecVP8, kCodecOpus, 0, 1},
    {kCodecVP8, kCodecOpus, 1, 1},
    {kCodecVP9, kCodecOpus, 1, 0},
    {kCodecVP9, kCodecOpus, 0, 1},
    {kCodecVP9, kCodecOpus, 1, 1},
    {kCodecH264, kCodecOpus, 1, 0},
    {kCodecH264, kCodecOpus, 0, 1},
    {kCodecH264, kCodecOpus, 1, 1},
    {kCodecVP8, kCodecPCM, 0, 1},
    {kCodecVP8, kCodecPCM, 1, 1},
};

INSTANTIATE_TEST_SUITE_P(All, WebmMuxerTest, ValuesIn(kTestCases));

class WebmMuxerTestUnparametrized : public testing::Test {
 public:
  WebmMuxerTestUnparametrized()
      : environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME),
        webm_muxer_(std::make_unique<WebmMuxer>(
            kCodecOpus,
            /*has_audio=*/true,
            /*has_video=*/true,
            base::BindRepeating(
                &WebmMuxerTestUnparametrized::SaveChunkAndInvokeWriteCallback,
                base::Unretained(this)))) {}

  bool Parse() {
    if (got_video_) {
      // Add one more video buffer to force WebMStreamParser to not hold back
      // the last added video buffer due to missing duration of it.
      AddVideoAtOffset(kSentinelVideoBufferTimestampMs, /*is_key_frame=*/false);
    }
    // Force any final flushes.
    webm_muxer_ = nullptr;
    media::WebMStreamParser parser;
    parser.Init(
        base::BindOnce(&WebmMuxerTestUnparametrized::OnInit,
                       base::Unretained(this)),
        base::BindRepeating(&WebmMuxerTestUnparametrized::OnNewConfig,
                            base::Unretained(this)),
        base::BindRepeating(&WebmMuxerTestUnparametrized::OnNewBuffers,
                            base::Unretained(this)),
        /*ignore_text_tracks=*/true,
        base::BindRepeating(
            &WebmMuxerTestUnparametrized::OnEncryptedMediaInitData,
            base::Unretained(this)),
        base::BindRepeating(&WebmMuxerTestUnparametrized::OnNewMediaSegment,
                            base::Unretained(this)),
        base::BindRepeating(&WebmMuxerTestUnparametrized::OnEndMediaSegment,
                            base::Unretained(this)),
        &media_log_);
    return parser.Parse(muxed_data_.data(), muxed_data_.size());
  }

  void AddVideoAtOffset(int system_timestamp_offset_ms, bool is_key_frame) {
    WebmMuxer::VideoParameters params(gfx::Size(1, 1), 0, media::kCodecVP8,
                                      gfx::ColorSpace());
    webm_muxer_->OnEncodedVideo(
        params, "video_at_offset", "",
        base::TimeTicks() +
            base::TimeDelta::FromMilliseconds(system_timestamp_offset_ms),
        is_key_frame);
    got_video_ = true;
  }

  void AddAudioAtOffsetWithDuration(int system_timestamp_offset_ms,
                                    int duration_ms) {
    int frame_rate_hz = 48000;
    int frames_per_buffer = frame_rate_hz * duration_ms / 1000;
    media::AudioParameters audio_params(
        media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
        media::CHANNEL_LAYOUT_MONO, frame_rate_hz, frames_per_buffer);
    webm_muxer_->OnEncodedAudio(
        audio_params, "audio_at_offset",
        base::TimeTicks() +
            base::TimeDelta::FromMilliseconds(system_timestamp_offset_ms));
  }

  MOCK_METHOD(void, OnWrite, ());

  base::test::TaskEnvironment environment_;
  std::unique_ptr<WebmMuxer> webm_muxer_;
  std::map<int, std::vector<int>> buffer_timestamps_ms_;

 protected:
  // media::StreamParser callbacks.
  void OnInit(const media::StreamParser::InitParameters&) {}
  bool OnNewConfig(std::unique_ptr<media::MediaTracks> tracks,
                   const media::StreamParser::TextTrackConfigMap&) {
    return true;
  }
  bool OnNewBuffers(const media::StreamParser::BufferQueueMap& map) {
    for (const auto& kv : map) {
      int track_id = kv.first;
      const media::StreamParser::BufferQueue& queue = kv.second;
      for (const auto& stream_parser_buffer : queue) {
        buffer_timestamps_ms_[track_id].push_back(
            stream_parser_buffer->timestamp().InMilliseconds());
      }
    }
    return true;
  }
  void OnEncryptedMediaInitData(EmeInitDataType, const std::vector<uint8_t>&) {}
  void OnNewMediaSegment() {}
  void OnEndMediaSegment() {}

 private:
  static constexpr int kSentinelVideoBufferTimestampMs = 1000000;

  void SaveChunkAndInvokeWriteCallback(base::StringPiece chunk) {
    OnWrite();
    std::copy(chunk.begin(), chunk.end(), std::back_inserter(muxed_data_));
  }

  // Muxed data gets saved here. The content is guaranteed to be finalized first
  // when webm_muxer_ has been destroyed.
  std::vector<unsigned char> muxed_data_;

  // Mock media log for WebM parser.
  media::MockMediaLog media_log_;

  // True after a call to AddVideoAtOffset.
  bool got_video_ = false;
};

TEST_F(WebmMuxerTestUnparametrized, MuxerCompensatesForPausedTimeWithVideo) {
  AddVideoAtOffset(123, /*is_key_frame=*/true);
  webm_muxer_->Pause();
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(200));
  webm_muxer_->Resume();
  AddVideoAtOffset(123 + 266, /*is_key_frame=*/false);
  EXPECT_TRUE(Parse());
  EXPECT_THAT(buffer_timestamps_ms_,
              ElementsAre(Pair(1, ElementsAre(0, /*266 - 200=*/66))));
}

TEST_F(WebmMuxerTestUnparametrized, MuxerCompensatesForPausedTimeWithAudio) {
  AddAudioAtOffsetWithDuration(234, 10);
  webm_muxer_->Pause();
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(666));
  webm_muxer_->Resume();
  AddAudioAtOffsetWithDuration(234 + 686, 10);
  EXPECT_TRUE(Parse());
  EXPECT_THAT(buffer_timestamps_ms_,
              ElementsAre(Pair(1, ElementsAre(0, /*686 - 666=*/20))));
}

TEST_F(WebmMuxerTestUnparametrized,
       MuxerCompensatesForPausedTimeWithAudioAndVideo) {
  AddAudioAtOffsetWithDuration(234, 10);
  AddVideoAtOffset(234 + 1, /*is_key_frame=*/true);
  webm_muxer_->Pause();
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(300));
  webm_muxer_->Resume();
  AddAudioAtOffsetWithDuration(234 + 321, 10);
  AddVideoAtOffset(234 + 315, /*is_key_frame=*/false);
  EXPECT_TRUE(Parse());
  EXPECT_THAT(
      buffer_timestamps_ms_,
      UnorderedElementsAre(Pair(1, ElementsAre(0, /*321 - 300=*/21)),
                           Pair(2, ElementsAre(0, /*315 - 300 - 1=*/14))));
}

TEST_F(WebmMuxerTestUnparametrized,
       MuxerCompensatesForPausedTimeBeforeAudioVideo) {
  webm_muxer_->Pause();
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(100));
  webm_muxer_->Resume();
  AddAudioAtOffsetWithDuration(50, 10);
  AddVideoAtOffset(65, /*is_key_frame=*/true);
  AddAudioAtOffsetWithDuration(60, 10);
  AddVideoAtOffset(70, /*is_key_frame=*/false);
  EXPECT_TRUE(Parse());
  EXPECT_THAT(buffer_timestamps_ms_,
              UnorderedElementsAre(Pair(1, ElementsAre(0, 10)),
                                   Pair(2, ElementsAre(0, 5))));
}

TEST_F(WebmMuxerTestUnparametrized, HoldsDataUntilDurationExpiry) {
  webm_muxer_->SetMaximumDurationToForceDataOutput(
      base::TimeDelta::FromMilliseconds(200));
  AddVideoAtOffset(0, /*is_key_frame=*/true);
  AddAudioAtOffsetWithDuration(0, 10);
  // Mute video. The muxer will hold on to audio data after this until the max
  // data output duration is expired.
  webm_muxer_->SetLiveAndEnabled(/*track_live_and_enabled=*/false,
                                 /*is_video=*/true);
  EXPECT_CALL(*this, OnWrite).Times(0);
  AddAudioAtOffsetWithDuration(10, 10);
  AddAudioAtOffsetWithDuration(20, 10);
  AddAudioAtOffsetWithDuration(30, 10);
  AddAudioAtOffsetWithDuration(40, 10);
  Mock::VerifyAndClearExpectations(this);
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(200));
  EXPECT_CALL(*this, OnWrite).Times(AtLeast(1));
  AddAudioAtOffsetWithDuration(50, 10);
  Mock::VerifyAndClearExpectations(this);
  // Stop mock dispatch from happening too late in the WebmMuxer's destructor.
  webm_muxer_ = nullptr;
}

TEST_F(WebmMuxerTestUnparametrized, DurationExpiryLimitedByMaxFrequency) {
  webm_muxer_->SetMaximumDurationToForceDataOutput(
      base::TimeDelta::FromMilliseconds(
          50));  // This value is below the minimum limit of 100 ms.
  AddVideoAtOffset(0, /*is_key_frame=*/true);
  AddAudioAtOffsetWithDuration(0, 10);
  // Mute video. The muxer will hold on to audio data after this until the max
  // data output duration is expired.
  webm_muxer_->SetLiveAndEnabled(/*track_live_and_enabled=*/false,
                                 /*is_video=*/true);
  EXPECT_CALL(*this, OnWrite).Times(0);
  AddAudioAtOffsetWithDuration(10, 10);
  AddAudioAtOffsetWithDuration(20, 10);
  AddAudioAtOffsetWithDuration(30, 10);
  AddAudioAtOffsetWithDuration(40, 10);
  Mock::VerifyAndClearExpectations(this);
  environment_.FastForwardBy(base::TimeDelta::FromMilliseconds(100));
  EXPECT_CALL(*this, OnWrite).Times(AtLeast(1));
  AddAudioAtOffsetWithDuration(50, 10);
  Mock::VerifyAndClearExpectations(this);
  // Stop mock dispatch from happening too late in the WebmMuxer's destructor.
  webm_muxer_ = nullptr;
}

}  // namespace media