// Copyright 2016 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/remoting/courier_renderer.h"

#include <memory>
#include <utility>
#include <vector>

#include "base/bind.h"
#include "base/check.h"
#include "base/run_loop.h"
#include "base/test/simple_test_tick_clock.h"
#include "base/test/task_environment.h"
#include "base/threading/thread_task_runner_handle.h"
#include "media/base/media_util.h"
#include "media/base/pipeline_status.h"
#include "media/base/renderer_client.h"
#include "media/base/test_helpers.h"
#include "media/remoting/fake_media_resource.h"
#include "media/remoting/fake_remoter.h"
#include "media/remoting/proto_enum_utils.h"
#include "media/remoting/proto_utils.h"
#include "media/remoting/renderer_controller.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/openscreen/src/cast/streaming/rpc_messenger.h"

using openscreen::cast::RpcMessenger;
using testing::_;
using testing::Invoke;
using testing::Return;

namespace media {
namespace remoting {

namespace {

PipelineMetadata DefaultMetadata() {
  PipelineMetadata data;
  data.has_audio = true;
  data.has_video = true;
  data.video_decoder_config = TestVideoConfig::Normal();
  return data;
}

PipelineStatistics DefaultStats() {
  PipelineStatistics stats;
  stats.audio_bytes_decoded = 1234U;
  stats.video_bytes_decoded = 2345U;
  stats.video_frames_decoded = 3000U;
  stats.video_frames_dropped = 91U;
  stats.audio_memory_usage = 5678;
  stats.video_memory_usage = 6789;
  stats.video_keyframe_distance_average = base::TimeDelta::Max();
  stats.audio_pipeline_info = {false, false, AudioDecoderType::kUnknown,
                               EncryptionType::kClear};
  stats.video_pipeline_info = {false, false, VideoDecoderType::kUnknown,
                               EncryptionType::kClear};
  return stats;
}

class RendererClientImpl final : public RendererClient {
 public:
  RendererClientImpl() {
    ON_CALL(*this, OnStatisticsUpdate(_))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnStatisticsUpdate));
    ON_CALL(*this, OnPipelineStatus(_))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnPipelineStatus));
    ON_CALL(*this, OnBufferingStateChange(_, _))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnBufferingStateChange));
    ON_CALL(*this, OnAudioConfigChange(_))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnAudioConfigChange));
    ON_CALL(*this, OnVideoConfigChange(_))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnVideoConfigChange));
    ON_CALL(*this, OnVideoNaturalSizeChange(_))
        .WillByDefault(Invoke(
            this, &RendererClientImpl::DelegateOnVideoNaturalSizeChange));
    ON_CALL(*this, OnVideoOpacityChange(_))
        .WillByDefault(
            Invoke(this, &RendererClientImpl::DelegateOnVideoOpacityChange));
  }

  RendererClientImpl(const RendererClientImpl&) = delete;
  RendererClientImpl& operator=(const RendererClientImpl&) = delete;

  ~RendererClientImpl() = default;

  // RendererClient implementation.
  void OnError(PipelineStatus status) override {}
  void OnEnded() override {}
  MOCK_METHOD1(OnStatisticsUpdate, void(const PipelineStatistics& stats));
  MOCK_METHOD2(OnBufferingStateChange,
               void(BufferingState state, BufferingStateChangeReason reason));
  MOCK_METHOD1(OnAudioConfigChange, void(const AudioDecoderConfig& config));
  MOCK_METHOD1(OnVideoConfigChange, void(const VideoDecoderConfig& config));
  void OnWaiting(WaitingReason reason) override {}
  MOCK_METHOD1(OnVideoNaturalSizeChange, void(const gfx::Size& size));
  MOCK_METHOD1(OnVideoOpacityChange, void(bool opaque));
  MOCK_METHOD1(OnVideoFrameRateChange, void(absl::optional<int>));
  MOCK_METHOD1(OnRemotePlayStateChange, void(MediaStatus::State state));

  void DelegateOnStatisticsUpdate(const PipelineStatistics& stats) {
    stats_ = stats;
  }
  void DelegateOnBufferingStateChange(BufferingState state,
                                      BufferingStateChangeReason reason) {
    state_ = state;
  }
  void DelegateOnAudioConfigChange(const AudioDecoderConfig& config) {
    audio_decoder_config_ = config;
  }
  void DelegateOnVideoConfigChange(const VideoDecoderConfig& config) {
    video_decoder_config_ = config;
  }
  void DelegateOnVideoNaturalSizeChange(const gfx::Size& size) { size_ = size; }
  void DelegateOnVideoOpacityChange(bool opaque) { opaque_ = opaque; }

  MOCK_METHOD1(OnPipelineStatus, void(PipelineStatus status));
  void DelegateOnPipelineStatus(PipelineStatus status) {
    VLOG(2) << "OnPipelineStatus status:" << status;
    status_ = status;
  }
  MOCK_METHOD0(OnFlushCallback, void());

  PipelineStatus status() const { return status_; }
  PipelineStatistics stats() const { return stats_; }
  BufferingState state() const { return state_; }
  gfx::Size size() const { return size_; }
  bool opaque() const { return opaque_; }
  VideoDecoderConfig video_decoder_config() const {
    return video_decoder_config_;
  }
  AudioDecoderConfig audio_decoder_config() const {
    return audio_decoder_config_;
  }

 private:
  PipelineStatus status_ = PIPELINE_OK;
  BufferingState state_ = BUFFERING_HAVE_NOTHING;
  gfx::Size size_;
  bool opaque_ = false;
  PipelineStatistics stats_;
  VideoDecoderConfig video_decoder_config_;
  AudioDecoderConfig audio_decoder_config_;
};

}  // namespace

class CourierRendererTest : public testing::Test {
 public:
  CourierRendererTest() = default;

  CourierRendererTest(const CourierRendererTest&) = delete;
  CourierRendererTest& operator=(const CourierRendererTest&) = delete;

  ~CourierRendererTest() override = default;

  // Use this function to mimic receiver to handle RPC message for renderer
  // initialization,
  void RpcMessageResponseBot(std::vector<uint8_t> message) {
    openscreen::cast::RpcMessage rpc;
    ASSERT_TRUE(rpc.ParseFromArray(message.data(), message.size()));
    switch (rpc.proc()) {
      case openscreen::cast::RpcMessage::RPC_ACQUIRE_RENDERER: {
        DCHECK(rpc.has_integer_value());
        sender_renderer_handle_ = rpc.integer_value();
        // Issues RPC_ACQUIRE_RENDERER_DONE RPC message.
        auto acquire_done = std::make_unique<openscreen::cast::RpcMessage>();
        acquire_done->set_handle(sender_renderer_handle_);
        acquire_done->set_proc(
            openscreen::cast::RpcMessage::RPC_ACQUIRE_RENDERER_DONE);
        acquire_done->set_integer_value(receiver_renderer_handle_);
        controller_->GetRpcMessenger()->ProcessMessageFromRemote(
            std::move(acquire_done));
      } break;
      case openscreen::cast::RpcMessage::RPC_ACQUIRE_DEMUXER: {
        if (!is_backward_compatible_mode_) {
          int acquire_demuxer_handle = RpcMessenger::kAcquireDemuxerHandle;
          EXPECT_EQ(rpc.handle(), acquire_demuxer_handle);
          sender_audio_demuxer_handle_ =
              rpc.acquire_demuxer_rpc().audio_demuxer_handle();
          sender_video_demuxer_handle_ =
              rpc.acquire_demuxer_rpc().video_demuxer_handle();

          // Issues audio RPC_DS_INITIALIZE RPC message.
          if (sender_audio_demuxer_handle_ != RpcMessenger::kInvalidHandle) {
            auto ds_init = std::make_unique<openscreen::cast::RpcMessage>();
            ds_init->set_handle(sender_audio_demuxer_handle_);
            ds_init->set_proc(openscreen::cast::RpcMessage::RPC_DS_INITIALIZE);
            ds_init->set_integer_value(receiver_audio_demuxer_callback_handle_);
            controller_->GetRpcMessenger()->ProcessMessageFromRemote(
                std::move(ds_init));
          }

          // Issues video RPC_DS_INITIALIZE RPC message.
          if (sender_video_demuxer_handle_ != RpcMessenger::kInvalidHandle) {
            auto ds_init = std::make_unique<openscreen::cast::RpcMessage>();
            ds_init->set_handle(sender_video_demuxer_handle_);
            ds_init->set_proc(openscreen::cast::RpcMessage::RPC_DS_INITIALIZE);
            ds_init->set_integer_value(receiver_video_demuxer_callback_handle_);
            controller_->GetRpcMessenger()->ProcessMessageFromRemote(
                std::move(ds_init));
          }
        }
      } break;
      case openscreen::cast::RpcMessage::RPC_R_INITIALIZE: {
        sender_renderer_callback_handle_ =
            rpc.renderer_initialize_rpc().callback_handle();
        sender_client_handle_ = rpc.renderer_initialize_rpc().client_handle();

        if (is_backward_compatible_mode_) {
          EXPECT_EQ(rpc.handle(), receiver_renderer_handle_);

          sender_audio_demuxer_handle_ =
              rpc.renderer_initialize_rpc().audio_demuxer_handle();
          sender_video_demuxer_handle_ =
              rpc.renderer_initialize_rpc().video_demuxer_handle();

          // Issues audio RPC_DS_INITIALIZE RPC message.
          if (sender_audio_demuxer_handle_ != RpcMessenger::kInvalidHandle) {
            auto ds_init = std::make_unique<openscreen::cast::RpcMessage>();
            ds_init->set_handle(sender_audio_demuxer_handle_);
            ds_init->set_proc(openscreen::cast::RpcMessage::RPC_DS_INITIALIZE);
            ds_init->set_integer_value(receiver_audio_demuxer_callback_handle_);
            controller_->GetRpcMessenger()->ProcessMessageFromRemote(
                std::move(ds_init));
          }

          // Issues video RPC_DS_INITIALIZE RPC message.
          if (sender_video_demuxer_handle_ != RpcMessenger::kInvalidHandle) {
            auto ds_init = std::make_unique<openscreen::cast::RpcMessage>();
            ds_init->set_handle(sender_video_demuxer_handle_);
            ds_init->set_proc(openscreen::cast::RpcMessage::RPC_DS_INITIALIZE);
            ds_init->set_integer_value(receiver_video_demuxer_callback_handle_);
            controller_->GetRpcMessenger()->ProcessMessageFromRemote(
                std::move(ds_init));
          }
        } else {
          // Issues RPC_R_INITIALIZE_CALLBACK RPC message when receiving
          // RPC_R_INITIALIZE.
          auto init_cb = std::make_unique<openscreen::cast::RpcMessage>();
          init_cb->set_handle(sender_renderer_callback_handle_);
          init_cb->set_proc(
              openscreen::cast::RpcMessage::RPC_R_INITIALIZE_CALLBACK);
          init_cb->set_boolean_value(is_successfully_initialized_);
          controller_->GetRpcMessenger()->ProcessMessageFromRemote(
              std::move(init_cb));
        }
      } break;
      case openscreen::cast::RpcMessage::RPC_DS_INITIALIZE_CALLBACK: {
        if (rpc.handle() == receiver_audio_demuxer_callback_handle_)
          received_audio_ds_init_cb_ = true;
        if (rpc.handle() == receiver_video_demuxer_callback_handle_)
          received_video_ds_init_cb_ = true;

        // Check whether the demuxer at the receiver end is initialized.
        if (received_audio_ds_init_cb_ == (sender_audio_demuxer_handle_ !=
                                           RpcMessenger::kInvalidHandle) &&
            received_video_ds_init_cb_ == (sender_video_demuxer_handle_ !=
                                           RpcMessenger::kInvalidHandle)) {
          is_receiver_demuxer_initialized_ = true;
        }

        if (is_backward_compatible_mode_ && is_receiver_demuxer_initialized_) {
          // Issues RPC_R_INITIALIZE_CALLBACK RPC message when receiving
          // RPC_DS_INITIALIZE_CALLBACK on available streams.
          auto init_cb = std::make_unique<openscreen::cast::RpcMessage>();
          init_cb->set_handle(sender_renderer_callback_handle_);
          init_cb->set_proc(
              openscreen::cast::RpcMessage::RPC_R_INITIALIZE_CALLBACK);
          init_cb->set_boolean_value(is_successfully_initialized_);
          controller_->GetRpcMessenger()->ProcessMessageFromRemote(
              std::move(init_cb));
        }
      } break;
      case openscreen::cast::RpcMessage::RPC_R_FLUSHUNTIL: {
        // Issues RPC_R_FLUSHUNTIL_CALLBACK RPC message.
        std::unique_ptr<openscreen::cast::RpcMessage> flush_cb(
            new openscreen::cast::RpcMessage());
        flush_cb->set_handle(rpc.renderer_flushuntil_rpc().callback_handle());
        flush_cb->set_proc(
            openscreen::cast::RpcMessage::RPC_R_FLUSHUNTIL_CALLBACK);
        controller_->GetRpcMessenger()->ProcessMessageFromRemote(
            std::move(flush_cb));
      } break;
      case openscreen::cast::RpcMessage::RPC_R_SETVOLUME:
        // No response needed.
        break;

      default:
        NOTREACHED();
    }
    RunPendingTasks();
  }

  // Callback from RpcMessenger when sending message to remote sink.
  void OnSendMessageToSink(std::vector<uint8_t> message) {
    openscreen::cast::RpcMessage rpc;
    ASSERT_TRUE(rpc.ParseFromArray(message.data(), message.size()));
    received_rpc_.push_back(std::move(rpc));
  }

  void RewireSendMessageCallbackToSink() {
    controller_->GetRpcMessenger()->set_send_message_cb_for_testing(
        [this](std::vector<uint8_t> message) {
          this->OnSendMessageToSink(message);
        });
  }

 protected:
  void InitializeRenderer() {
    // Register media::RendererClient implementation.
    render_client_ = std::make_unique<RendererClientImpl>();
    media_resource_ = std::make_unique<FakeMediaResource>();
    EXPECT_CALL(*render_client_, OnPipelineStatus(_)).Times(1);
    DCHECK(renderer_);
    // Redirect RPC message for simulate receiver scenario
    controller_->GetRpcMessenger()->set_send_message_cb_for_testing(
        [this](std::vector<uint8_t> message) {
          this->RpcMessageResponseBot(message);
        });
    RunPendingTasks();
    renderer_->Initialize(
        media_resource_.get(), render_client_.get(),
        base::BindOnce(&RendererClientImpl::OnPipelineStatus,
                       base::Unretained(render_client_.get())));
    RunPendingTasks();
    RewireSendMessageCallbackToSink();
    RunPendingTasks();
  }

  void InitializeRendererBackwardsCompatible() {
    is_backward_compatible_mode_ = true;
    InitializeRenderer();
  }

  bool IsRendererInitialized() const {
    EXPECT_TRUE(received_audio_ds_init_cb_);
    EXPECT_TRUE(received_video_ds_init_cb_);
    return renderer_->state_ == CourierRenderer::STATE_PLAYING &&
           is_receiver_demuxer_initialized_;
  }

  bool DidEncounterFatalError() const {
    return renderer_->state_ == CourierRenderer::STATE_ERROR;
  }

  void OnReceivedRpc(std::unique_ptr<openscreen::cast::RpcMessage> message) {
    renderer_->OnReceivedRpc(std::move(message));
  }

  void SetUp() override {
    controller_ = FakeRemoterFactory::CreateController(false);
    controller_->OnMetadataChanged(DefaultMetadata());

    RewireSendMessageCallbackToSink();
    renderer_ =
        std::make_unique<CourierRenderer>(base::ThreadTaskRunnerHandle::Get(),
                                          controller_->GetWeakPtr(), nullptr);
    renderer_->clock_ = &clock_;
    clock_.Advance(base::Seconds(1));

    RunPendingTasks();
  }

  CourierRenderer::State state() const { return renderer_->state_; }

  void RunPendingTasks() { base::RunLoop().RunUntilIdle(); }

  // Gets first available RpcMessage with specific |proc|.
  const openscreen::cast::RpcMessage* PeekRpcMessage(int proc) const {
    for (auto& s : received_rpc_) {
      if (proc == s.proc())
        return &s;
    }

    return nullptr;
  }
  int ReceivedRpcMessageCount() const { return received_rpc_.size(); }
  void ResetReceivedRpcMessage() { received_rpc_.clear(); }

  void ValidateCurrentTime(base::TimeDelta current,
                           base::TimeDelta current_max) const {
    ASSERT_EQ(renderer_->current_media_time_, current);
    ASSERT_EQ(renderer_->current_max_time_, current_max);
  }

  // Issues RPC_RC_ONTIMEUPDATE RPC message.
  void IssueTimeUpdateRpc(base::TimeDelta media_time,
                          base::TimeDelta max_media_time) {
    std::unique_ptr<openscreen::cast::RpcMessage> rpc(
        new openscreen::cast::RpcMessage());
    rpc->set_handle(5);
    rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONTIMEUPDATE);
    auto* time_message = rpc->mutable_rendererclient_ontimeupdate_rpc();
    time_message->set_time_usec(media_time.InMicroseconds());
    time_message->set_max_time_usec(max_media_time.InMicroseconds());
    OnReceivedRpc(std::move(rpc));
    RunPendingTasks();
  }

  // Verifies no error reported and issues a series of time updates RPC
  // messages. No verification after the last message is issued.
  void VerifyAndReportTimeUpdates(int start_serial_number,
                                  int end_serial_number) {
    for (int i = start_serial_number; i < end_serial_number; ++i) {
      ASSERT_FALSE(DidEncounterFatalError());
      IssueTimeUpdateRpc(base::Milliseconds(100 + i * 800), base::Seconds(100));
      clock_.Advance(base::Seconds(1));
      RunPendingTasks();
    }
  }

  // Issues RPC_RC_ONSTATISTICSUPDATE RPC message with DefaultStats().
  void IssueStatisticsUpdateRpc() {
    EXPECT_CALL(*render_client_, OnStatisticsUpdate(_)).Times(1);
    const PipelineStatistics stats = DefaultStats();
    std::unique_ptr<openscreen::cast::RpcMessage> rpc(
        new openscreen::cast::RpcMessage());
    rpc->set_handle(5);
    rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONSTATISTICSUPDATE);
    auto* message = rpc->mutable_rendererclient_onstatisticsupdate_rpc();
    message->set_audio_bytes_decoded(stats.audio_bytes_decoded);
    message->set_video_bytes_decoded(stats.video_bytes_decoded);
    message->set_video_frames_decoded(stats.video_frames_decoded);
    message->set_video_frames_dropped(stats.video_frames_dropped);
    message->set_audio_memory_usage(stats.audio_memory_usage);
    message->set_video_memory_usage(stats.video_memory_usage);
    message->mutable_audio_decoder_info()->set_is_platform_decoder(
        stats.audio_pipeline_info.is_platform_decoder);
    message->mutable_audio_decoder_info()->set_decoder_type(
        static_cast<int64_t>(stats.audio_pipeline_info.decoder_type));
    message->mutable_video_decoder_info()->set_is_platform_decoder(
        stats.video_pipeline_info.is_platform_decoder);
    message->mutable_video_decoder_info()->set_decoder_type(
        static_cast<int64_t>(stats.video_pipeline_info.decoder_type));
    OnReceivedRpc(std::move(rpc));
    RunPendingTasks();
  }

  // Issue RPC_RC_ONBUFFERINGSTATECHANGE RPC message.
  void IssuesBufferingStateRpc(BufferingState state) {
    absl::optional<
        openscreen::cast::RendererClientOnBufferingStateChange::State>
        pb_state = ToProtoMediaBufferingState(state);
    if (!pb_state.has_value())
      return;
    std::unique_ptr<openscreen::cast::RpcMessage> rpc(
        new openscreen::cast::RpcMessage());
    rpc->set_handle(5);
    rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONBUFFERINGSTATECHANGE);
    auto* buffering_state =
        rpc->mutable_rendererclient_onbufferingstatechange_rpc();
    buffering_state->set_state(pb_state.value());
    OnReceivedRpc(std::move(rpc));
    RunPendingTasks();
  }

  base::test::SingleThreadTaskEnvironment task_environment_;
  std::unique_ptr<RendererController> controller_;
  std::unique_ptr<RendererClientImpl> render_client_;
  std::unique_ptr<FakeMediaResource> media_resource_;
  std::unique_ptr<CourierRenderer> renderer_;
  base::SimpleTestTickClock clock_;

  // RPC handles.
  const int receiver_renderer_handle_{10};
  const int receiver_audio_demuxer_callback_handle_{11};
  const int receiver_video_demuxer_callback_handle_{12};
  int sender_renderer_handle_;
  int sender_client_handle_{RpcMessenger::kInvalidHandle};
  int sender_renderer_callback_handle_{RpcMessenger::kInvalidHandle};
  int sender_audio_demuxer_handle_{RpcMessenger::kInvalidHandle};
  int sender_video_demuxer_handle_{RpcMessenger::kInvalidHandle};

  // Indicates whether the test runs in backward-compatible mode.
  bool is_backward_compatible_mode_ = false;

  // Indicates whether the demuxer at receiver is initialized or not.
  bool is_receiver_demuxer_initialized_ = false;

  // Indicate whether RPC_DS_INITIALIZE_CALLBACK RPC messages are received.
  bool received_audio_ds_init_cb_ = false;
  bool received_video_ds_init_cb_ = false;

  // Indicates whether the test wants to simulate successful initialization in
  // the renderer on the receiver side.
  bool is_successfully_initialized_ = true;

  // Stores RPC messages that have been sent to the remote sink.
  std::vector<openscreen::cast::RpcMessage> received_rpc_;
};

TEST_F(CourierRendererTest, Initialize) {
  InitializeRenderer();
  RunPendingTasks();

  ASSERT_TRUE(IsRendererInitialized());
  ASSERT_EQ(render_client_->status(), PIPELINE_OK);
}

TEST_F(CourierRendererTest, InitializeBackwardCompatible) {
  InitializeRendererBackwardsCompatible();
  RunPendingTasks();

  ASSERT_TRUE(IsRendererInitialized());
  ASSERT_EQ(render_client_->status(), PIPELINE_OK);
}

TEST_F(CourierRendererTest, InitializeFailed) {
  is_successfully_initialized_ = false;
  InitializeRenderer();
  RunPendingTasks();
  ASSERT_FALSE(IsRendererInitialized());
  ASSERT_TRUE(DidEncounterFatalError());
  // Don't report error to prevent breaking the pipeline.
  ASSERT_EQ(render_client_->status(), PIPELINE_OK);

  // The CourierRenderer should act as a no-op renderer from this point.

  ResetReceivedRpcMessage();
  EXPECT_CALL(*render_client_, OnFlushCallback()).Times(1);
  renderer_->Flush(base::BindOnce(&RendererClientImpl::OnFlushCallback,
                                  base::Unretained(render_client_.get())));
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());

  base::TimeDelta seek = base::Microseconds(100);
  renderer_->StartPlayingFrom(seek);
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());

  renderer_->SetVolume(3.0);
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());

  renderer_->SetPlaybackRate(2.5);
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());
}

TEST_F(CourierRendererTest, Flush) {
  // Initialize Renderer.
  InitializeRenderer();
  RunPendingTasks();
  ASSERT_TRUE(IsRendererInitialized());
  ASSERT_EQ(render_client_->status(), PIPELINE_OK);

  // Flush Renderer.
  // Redirect RPC message for simulate receiver scenario
  controller_->GetRpcMessenger()->set_send_message_cb_for_testing(
      [this](std::vector<uint8_t> message) {
        this->RpcMessageResponseBot(message);
      });
  RunPendingTasks();
  EXPECT_CALL(*render_client_, OnFlushCallback()).Times(1);
  renderer_->Flush(base::BindOnce(&RendererClientImpl::OnFlushCallback,
                                  base::Unretained(render_client_.get())));
  RunPendingTasks();
}

TEST_F(CourierRendererTest, StartPlayingFrom) {
  // Initialize Renderer
  InitializeRenderer();
  RunPendingTasks();
  ASSERT_TRUE(IsRendererInitialized());
  ASSERT_EQ(render_client_->status(), PIPELINE_OK);

  // StartPlaying from
  base::TimeDelta seek = base::Microseconds(100);
  renderer_->StartPlayingFrom(seek);
  RunPendingTasks();

  // Checks if it sends out RPC message with correct value.
  ASSERT_EQ(1, ReceivedRpcMessageCount());
  const openscreen::cast::RpcMessage* rpc =
      PeekRpcMessage(openscreen::cast::RpcMessage::RPC_R_STARTPLAYINGFROM);
  ASSERT_TRUE(rpc);
  ASSERT_EQ(100, rpc->integer64_value());
}

TEST_F(CourierRendererTest, SetVolume) {
  // Initialize Renderer because, as of this writing, the pipeline guarantees it
  // will not call SetVolume() until after the media::Renderer is initialized.
  InitializeRenderer();
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());

  // SetVolume() will send openscreen::cast::RpcMessage::RPC_R_SETVOLUME RPC.
  renderer_->SetVolume(3.0);
  RunPendingTasks();

  // Checks if it sends out RPC message with correct value.
  ASSERT_EQ(1, ReceivedRpcMessageCount());
  const openscreen::cast::RpcMessage* rpc =
      PeekRpcMessage(openscreen::cast::RpcMessage::RPC_R_SETVOLUME);
  ASSERT_TRUE(rpc);
  ASSERT_DOUBLE_EQ(3.0, rpc->double_value());
}

TEST_F(CourierRendererTest, SetPlaybackRate) {
  // Initialize Renderer because, as of this writing, the pipeline guarantees it
  // will not call SetPlaybackRate() until after the media::Renderer is
  // initialized.
  InitializeRenderer();
  RunPendingTasks();
  ASSERT_EQ(0, ReceivedRpcMessageCount());

  renderer_->SetPlaybackRate(2.5);
  RunPendingTasks();
  ASSERT_EQ(1, ReceivedRpcMessageCount());
  // Checks if it sends out RPC message with correct value.
  const openscreen::cast::RpcMessage* rpc =
      PeekRpcMessage(openscreen::cast::RpcMessage::RPC_R_SETPLAYBACKRATE);
  ASSERT_TRUE(rpc);
  ASSERT_DOUBLE_EQ(2.5, rpc->double_value());
}

TEST_F(CourierRendererTest, OnTimeUpdate) {
  base::TimeDelta media_time = base::Microseconds(100);
  base::TimeDelta max_media_time = base::Microseconds(500);
  IssueTimeUpdateRpc(media_time, max_media_time);
  ValidateCurrentTime(media_time, max_media_time);

  // Issues RPC_RC_ONTIMEUPDATE RPC message with invalid time
  base::TimeDelta media_time2 = base::Microseconds(-100);
  base::TimeDelta max_media_time2 = base::Microseconds(500);
  IssueTimeUpdateRpc(media_time2, max_media_time2);
  // Because of invalid value, the time will not be updated and remain the same.
  ValidateCurrentTime(media_time, max_media_time);
}

TEST_F(CourierRendererTest, OnBufferingStateChange) {
  InitializeRenderer();
  EXPECT_CALL(*render_client_,
              OnBufferingStateChange(BUFFERING_HAVE_NOTHING, _))
      .Times(1);
  IssuesBufferingStateRpc(BufferingState::BUFFERING_HAVE_NOTHING);
}

TEST_F(CourierRendererTest, OnAudioConfigChange) {
  const AudioDecoderConfig kNewAudioConfig(
      AudioCodec::kVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
      EmptyExtraData(), EncryptionScheme::kUnencrypted);
  InitializeRenderer();
  // Make sure initial audio config does not match the one we intend to send.
  ASSERT_FALSE(render_client_->audio_decoder_config().Matches(kNewAudioConfig));
  // Issues RPC_RC_ONVIDEOCONFIGCHANGE RPC message.
  EXPECT_CALL(*render_client_,
              OnAudioConfigChange(DecoderConfigEq(kNewAudioConfig)))
      .Times(1);

  std::unique_ptr<openscreen::cast::RpcMessage> rpc(
      new openscreen::cast::RpcMessage());
  rpc->set_handle(5);
  rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONAUDIOCONFIGCHANGE);
  auto* audio_config_change_message =
      rpc->mutable_rendererclient_onaudioconfigchange_rpc();
  openscreen::cast::AudioDecoderConfig* proto_audio_config =
      audio_config_change_message->mutable_audio_decoder_config();
  ConvertAudioDecoderConfigToProto(kNewAudioConfig, proto_audio_config);
  OnReceivedRpc(std::move(rpc));
  RunPendingTasks();
  ASSERT_TRUE(render_client_->audio_decoder_config().Matches(kNewAudioConfig));
}

TEST_F(CourierRendererTest, OnVideoConfigChange) {
  const auto kNewVideoConfig = TestVideoConfig::Normal();
  InitializeRenderer();
  // Make sure initial video config does not match the one we intend to send.
  ASSERT_FALSE(render_client_->video_decoder_config().Matches(kNewVideoConfig));
  // Issues RPC_RC_ONVIDEOCONFIGCHANGE RPC message.
  EXPECT_CALL(*render_client_,
              OnVideoConfigChange(DecoderConfigEq(kNewVideoConfig)))
      .Times(1);

  std::unique_ptr<openscreen::cast::RpcMessage> rpc(
      new openscreen::cast::RpcMessage());
  rpc->set_handle(5);
  rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONVIDEOCONFIGCHANGE);
  auto* video_config_change_message =
      rpc->mutable_rendererclient_onvideoconfigchange_rpc();
  openscreen::cast::VideoDecoderConfig* proto_video_config =
      video_config_change_message->mutable_video_decoder_config();
  ConvertVideoDecoderConfigToProto(kNewVideoConfig, proto_video_config);
  OnReceivedRpc(std::move(rpc));
  RunPendingTasks();
  ASSERT_TRUE(render_client_->video_decoder_config().Matches(kNewVideoConfig));
}

TEST_F(CourierRendererTest, OnVideoNaturalSizeChange) {
  InitializeRenderer();
  // Makes sure initial value of video natural size is not set to
  // gfx::Size(100, 200).
  ASSERT_NE(render_client_->size().width(), 100);
  ASSERT_NE(render_client_->size().height(), 200);
  // Issues RPC_RC_ONVIDEONATURALSIZECHANGE RPC message.
  EXPECT_CALL(*render_client_, OnVideoNaturalSizeChange(gfx::Size(100, 200)))
      .Times(1);
  std::unique_ptr<openscreen::cast::RpcMessage> rpc(
      new openscreen::cast::RpcMessage());
  rpc->set_handle(5);
  rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONVIDEONATURALSIZECHANGE);
  auto* size_message =
      rpc->mutable_rendererclient_onvideonatualsizechange_rpc();
  size_message->set_width(100);
  size_message->set_height(200);
  OnReceivedRpc(std::move(rpc));
  RunPendingTasks();
  ASSERT_EQ(render_client_->size().width(), 100);
  ASSERT_EQ(render_client_->size().height(), 200);
}

TEST_F(CourierRendererTest, OnVideoNaturalSizeChangeWithInvalidValue) {
  InitializeRenderer();
  // Issues RPC_RC_ONVIDEONATURALSIZECHANGE RPC message.
  EXPECT_CALL(*render_client_, OnVideoNaturalSizeChange(_)).Times(0);
  std::unique_ptr<openscreen::cast::RpcMessage> rpc(
      new openscreen::cast::RpcMessage());
  rpc->set_handle(5);
  rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONVIDEONATURALSIZECHANGE);
  auto* size_message =
      rpc->mutable_rendererclient_onvideonatualsizechange_rpc();
  size_message->set_width(-100);
  size_message->set_height(0);
  OnReceivedRpc(std::move(rpc));
  RunPendingTasks();
}

TEST_F(CourierRendererTest, OnVideoOpacityChange) {
  InitializeRenderer();
  ASSERT_FALSE(render_client_->opaque());
  // Issues RPC_RC_ONVIDEOOPACITYCHANGE RPC message.
  EXPECT_CALL(*render_client_, OnVideoOpacityChange(true)).Times(1);
  std::unique_ptr<openscreen::cast::RpcMessage> rpc(
      new openscreen::cast::RpcMessage());
  rpc->set_handle(5);
  rpc->set_proc(openscreen::cast::RpcMessage::RPC_RC_ONVIDEOOPACITYCHANGE);
  rpc->set_boolean_value(true);
  OnReceivedRpc(std::move(rpc));
  RunPendingTasks();
  ASSERT_TRUE(render_client_->opaque());
}

TEST_F(CourierRendererTest, OnStatisticsUpdate) {
  InitializeRenderer();
  EXPECT_NE(DefaultStats(), render_client_->stats());
  IssueStatisticsUpdateRpc();
  EXPECT_EQ(DefaultStats(), render_client_->stats());
}

TEST_F(CourierRendererTest, OnPacingTooSlowly) {
  InitializeRenderer();
  RewireSendMessageCallbackToSink();

  // There should be no error reported with this playback rate.
  renderer_->SetPlaybackRate(0.8);
  RunPendingTasks();
  EXPECT_CALL(*render_client_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH, _))
      .Times(1);
  IssuesBufferingStateRpc(BufferingState::BUFFERING_HAVE_ENOUGH);
  clock_.Advance(base::Seconds(3));
  VerifyAndReportTimeUpdates(0, 15);
  ASSERT_FALSE(DidEncounterFatalError());

  // Change playback rate. Pacing keeps same as above. Should report error when
  // playback was continuously delayed for 10 times.
  renderer_->SetPlaybackRate(1);
  RunPendingTasks();
  clock_.Advance(base::Seconds(3));
  VerifyAndReportTimeUpdates(15, 30);
  ASSERT_TRUE(DidEncounterFatalError());
}

TEST_F(CourierRendererTest, OnFrameDropRateHigh) {
  InitializeRenderer();

  for (int i = 0; i < 7; ++i) {
    ASSERT_FALSE(DidEncounterFatalError());  // Not enough measurements.
    IssueStatisticsUpdateRpc();
    clock_.Advance(base::Seconds(1));
    RunPendingTasks();
  }
  ASSERT_TRUE(DidEncounterFatalError());
}

}  // namespace remoting
}  // namespace media