Media Remoting Clean-up: Less-redundant naming, style consistency, etc.

media/remoting/remote_demuxer_stream_adapter_unittest.cc

Index: media/remoting/remote_demuxer_stream_adapter_unittest.cc
diff --git a/media/remoting/remote_demuxer_stream_adapter_unittest.cc b/media/remoting/remote_demuxer_stream_adapter_unittest.cc
deleted file mode 100644
index 26ac2dedd0ad5f3f7e40b3edf1f6eaf216956809..0000000000000000000000000000000000000000
--- a/media/remoting/remote_demuxer_stream_adapter_unittest.cc
+++ /dev/null
@@ -1,298 +0,0 @@
-// 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/remote_demuxer_stream_adapter.h"
-
-#include <memory>
-#include <vector>
-
-#include "base/callback_helpers.h"
-#include "base/run_loop.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/demuxer_stream.h"
-#include "media/remoting/fake_remoting_controller.h"
-#include "media/remoting/fake_remoting_demuxer_stream_provider.h"
-#include "media/remoting/rpc/proto_utils.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using testing::_;
-using testing::Invoke;
-using testing::Return;
-
-namespace media {
-namespace remoting {
-
-class MockRemoteDemuxerStreamAdapter {
- public:
-  MockRemoteDemuxerStreamAdapter(
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-      const std::string& name,
-      ::media::DemuxerStream* demuxer_stream,
-      mojom::RemotingDataStreamSenderPtrInfo stream_sender_info,
-      mojo::ScopedDataPipeProducerHandle producer_handle)
-      : weak_factory_(this) {
-    rpc_broker_.reset(new RpcBroker(
-        base::Bind(&MockRemoteDemuxerStreamAdapter::OnSendMessageToSink,
-                   weak_factory_.GetWeakPtr())));
-    demuxer_stream_adapter_.reset(new RemoteDemuxerStreamAdapter(
-        std::move(main_task_runner), std::move(media_task_runner), name,
-        demuxer_stream, rpc_broker_->GetWeakPtr(),
-        rpc_broker_->GetUniqueHandle(), std::move(stream_sender_info),
-        std::move(producer_handle),
-        base::Bind(&MockRemoteDemuxerStreamAdapter::OnError,
-                   weak_factory_.GetWeakPtr())));
-
-    // Faking initialization with random callback handle to start mojo watcher.
-    demuxer_stream_adapter_->Initialize(3);
-  }
-
-  ~MockRemoteDemuxerStreamAdapter() {
-    // Make sure unit tests that did not expect errors did not cause any errors.
-    EXPECT_TRUE(errors_.empty());
-  }
-
-  int rpc_handle() const { return demuxer_stream_adapter_->rpc_handle(); }
-
-  base::WeakPtr<MockRemoteDemuxerStreamAdapter> GetWeakPtr() {
-    return weak_factory_.GetWeakPtr();
-  }
-
-  void DoDuplicateInitialize() { demuxer_stream_adapter_->Initialize(999); }
-
-  void TakeErrors(std::vector<StopTrigger>* errors) {
-    errors->swap(errors_);
-    errors_.clear();
-  }
-
-  // Fake to signal that it's in reading state.
-  void FakeReadUntil(int read_until_count, int callback_handle) {
-    std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
-    rpc->set_handle(rpc_handle());
-    rpc->set_proc(pb::RpcMessage::RPC_DS_READUNTIL);
-    auto* read_message = rpc->mutable_demuxerstream_readuntil_rpc();
-    read_message->set_callback_handle(
-        callback_handle);  // Given an unique callback handle.
-    read_message->set_count(read_until_count);  // Request 1 frame
-
-    demuxer_stream_adapter_->OnReceivedRpc(std::move(rpc));
-  }
-  void OnNewBuffer(const scoped_refptr<::media::DecoderBuffer>& frame) {
-    demuxer_stream_adapter_->OnNewBuffer(DemuxerStream::kOk, frame);
-  }
-
-  void SignalFlush(bool flush) { demuxer_stream_adapter_->SignalFlush(flush); }
-
-  pb::RpcMessage* last_received_rpc() const { return last_received_rpc_.get(); }
-
- private:
-  void OnSendMessageToSink(std::unique_ptr<std::vector<uint8_t>> message) {
-    last_received_rpc_.reset(new remoting::pb::RpcMessage());
-    CHECK(last_received_rpc_->ParseFromArray(message->data(), message->size()));
-  }
-
-  void OnError(StopTrigger stop_trigger) { errors_.push_back(stop_trigger); }
-
-  std::unique_ptr<RpcBroker> rpc_broker_;
-  std::unique_ptr<RemoteDemuxerStreamAdapter> demuxer_stream_adapter_;
-  std::unique_ptr<remoting::pb::RpcMessage> last_received_rpc_;
-
-  std::vector<StopTrigger> errors_;
-
-  base::WeakPtrFactory<MockRemoteDemuxerStreamAdapter> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockRemoteDemuxerStreamAdapter);
-};
-
-class RemoteDemuxerStreamAdapterTest : public ::testing::Test {
- public:
-  RemoteDemuxerStreamAdapterTest() {}
-  ~RemoteDemuxerStreamAdapterTest() override = default;
-
-  void SetUpDataPipe() {
-    constexpr size_t kDataPipeCapacity = 256;
-    demuxer_stream_.reset(new DummyDemuxerStream(true));  // audio.
-    const MojoCreateDataPipeOptions data_pipe_options{
-        sizeof(MojoCreateDataPipeOptions),
-        MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, 1, kDataPipeCapacity};
-    mojom::RemotingDataStreamSenderPtr stream_sender;
-    mojo::ScopedDataPipeProducerHandle producer_end;
-    mojo::ScopedDataPipeConsumerHandle consumer_end;
-    CHECK_EQ(
-        MOJO_RESULT_OK,
-        mojo::CreateDataPipe(&data_pipe_options, &producer_end, &consumer_end));
-
-    data_stream_sender_.reset(new FakeRemotingDataStreamSender(
-        MakeRequest(&stream_sender), std::move(consumer_end)));
-    demuxer_stream_adapter_.reset(new MockRemoteDemuxerStreamAdapter(
-        message_loop_.task_runner(), message_loop_.task_runner(), "test",
-        demuxer_stream_.get(), stream_sender.PassInterface(),
-        std::move(producer_end)));
-    // RemoteDemuxerStreamAdapter constructor posts task to main thread to
-    // register MessageReceiverCallback. Therefore it should call
-    // RunPendingTasks() to make sure task is executed.
-    RunPendingTasks();
-  }
-
-  void TearDown() override { base::RunLoop().RunUntilIdle(); }
-
-  void RunPendingTasks() { base::RunLoop().RunUntilIdle(); }
-
- protected:
-  void SetUp() override { SetUpDataPipe(); }
-
-  // TODO(miu): Add separate media thread, to test threading also.
-  base::MessageLoop message_loop_;
-  std::unique_ptr<DummyDemuxerStream> demuxer_stream_;
-  std::unique_ptr<FakeRemotingDataStreamSender> data_stream_sender_;
-  std::unique_ptr<MockRemoteDemuxerStreamAdapter> demuxer_stream_adapter_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(RemoteDemuxerStreamAdapterTest);
-};
-
-TEST_F(RemoteDemuxerStreamAdapterTest, SingleReadUntil) {
-  // Read will be called once since it doesn't return frame buffer in the dummy
-  // implementation.
-  EXPECT_CALL(*demuxer_stream_, Read(_)).Times(1);
-
-  demuxer_stream_adapter_->FakeReadUntil(3, 999);
-  RunPendingTasks();
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, MultiReadUntil) {
-  // Read will be called once since it doesn't return frame buffer in the dummy
-  // implementation, and 2nd one will not proceed when there is ongoing read.
-  EXPECT_CALL(*demuxer_stream_, Read(_)).Times(1);
-
-  demuxer_stream_adapter_->FakeReadUntil(1, 100);
-  RunPendingTasks();
-
-  demuxer_stream_adapter_->FakeReadUntil(2, 101);
-  RunPendingTasks();
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameSmallerThanCapacity) {
-  // Sends a frame with size 50 bytes, pts = 1 and key frame.
-  demuxer_stream_->CreateFakeFrame(50, true, 1 /* pts */);
-  demuxer_stream_adapter_->FakeReadUntil(1, 999);
-  RunPendingTasks();
-
-  // Checks if it's sent to consumer side and data is correct
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 1U);
-  ASSERT_EQ(data_stream_sender_->consume_data_chunk_count(), 1U);
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(0, 50, true, 1));
-  pb::RpcMessage* last_rpc = demuxer_stream_adapter_->last_received_rpc();
-  ASSERT_TRUE(last_rpc);
-  ASSERT_EQ(last_rpc->proc(), pb::RpcMessage::RPC_DS_READUNTIL_CALLBACK);
-  ASSERT_EQ(last_rpc->handle(), 999);
-  data_stream_sender_->ResetHistory();
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameLargerThanCapacity) {
-  // Sends a frame with size 800 bytes, pts = 1 and key frame.
-  demuxer_stream_->CreateFakeFrame(800, true, 1 /* pts */);
-  demuxer_stream_adapter_->FakeReadUntil(1, 999);
-  RunPendingTasks();
-
-  // Checks if it's sent to consumer side and data is correct
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 1U);
-  ASSERT_EQ(data_stream_sender_->consume_data_chunk_count(), 4U);
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(0, 800, true, 1));
-  pb::RpcMessage* last_rpc = demuxer_stream_adapter_->last_received_rpc();
-  ASSERT_TRUE(last_rpc);
-  ASSERT_EQ(last_rpc->proc(), pb::RpcMessage::RPC_DS_READUNTIL_CALLBACK);
-  ASSERT_EQ(last_rpc->handle(), 999);
-  data_stream_sender_->ResetHistory();
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, SendFrameAndSignalFlushMix) {
-  // Sends a frame with size 50 bytes, pts = 1 and key frame.
-  demuxer_stream_->CreateFakeFrame(50, true, 1 /* pts */);
-  // Issues ReadUntil request with frame count up to 1 (fetch #0).
-  demuxer_stream_adapter_->FakeReadUntil(1, 100);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 1U);
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(0, 50, true, 1));
-  pb::RpcMessage* last_rpc = demuxer_stream_adapter_->last_received_rpc();
-  ASSERT_TRUE(last_rpc);
-  ASSERT_EQ(last_rpc->proc(), pb::RpcMessage::RPC_DS_READUNTIL_CALLBACK);
-  ASSERT_EQ(last_rpc->handle(), 100);
-  data_stream_sender_->ResetHistory();
-
-  // Sends two frames with size 100 + 150 bytes
-  demuxer_stream_->CreateFakeFrame(100, false, 2 /* pts */);
-  demuxer_stream_->CreateFakeFrame(150, false, 3 /* pts */);
-  // Issues ReadUntil request with frame count up to 3 (fetch #1 and #2).
-  demuxer_stream_adapter_->FakeReadUntil(3, 101);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 2U);
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(0, 100, false, 2));
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(1, 150, false, 3));
-  last_rpc = demuxer_stream_adapter_->last_received_rpc();
-  ASSERT_TRUE(last_rpc);
-  ASSERT_EQ(last_rpc->proc(), pb::RpcMessage::RPC_DS_READUNTIL_CALLBACK);
-  ASSERT_EQ(last_rpc->handle(), 101);
-  data_stream_sender_->ResetHistory();
-
-  // Signal flush
-  ASSERT_EQ(data_stream_sender_->cancel_in_flight_count(), 0U);
-  demuxer_stream_adapter_->SignalFlush(true);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->cancel_in_flight_count(), 1U);
-
-  // ReadUntil request after flush signaling should be ignored.
-  demuxer_stream_->CreateFakeFrame(100, false, 4 /* pts */);
-  demuxer_stream_->CreateFakeFrame(100, false, 5 /* pts */);
-  // Issues ReadUntil request with frame count up to 5 (fetch #3 and #4).
-  demuxer_stream_adapter_->FakeReadUntil(5, 102);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 0U);
-
-  // Signal flush done
-  demuxer_stream_adapter_->SignalFlush(false);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->cancel_in_flight_count(), 1U);
-  data_stream_sender_->ResetHistory();
-
-  // Re-issues ReadUntil request with frame count up to 4 (fetch #3).
-  demuxer_stream_adapter_->FakeReadUntil(4, 103);
-  RunPendingTasks();
-  ASSERT_EQ(data_stream_sender_->send_frame_count(), 1U);
-  ASSERT_TRUE(data_stream_sender_->ValidateFrameBuffer(0, 100, false, 4));
-  last_rpc = demuxer_stream_adapter_->last_received_rpc();
-  ASSERT_TRUE(last_rpc);
-  ASSERT_EQ(last_rpc->proc(), pb::RpcMessage::RPC_DS_READUNTIL_CALLBACK);
-  ASSERT_EQ(last_rpc->handle(), 103);
-  data_stream_sender_->ResetHistory();
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, DuplicateInitializeCausesFatalError) {
-  std::vector<StopTrigger> errors;
-  demuxer_stream_adapter_->TakeErrors(&errors);
-  ASSERT_TRUE(errors.empty());
-
-  demuxer_stream_adapter_->DoDuplicateInitialize();
-  demuxer_stream_adapter_->TakeErrors(&errors);
-  ASSERT_EQ(1u, errors.size());
-  EXPECT_EQ(PEERS_OUT_OF_SYNC, errors[0]);
-}
-
-TEST_F(RemoteDemuxerStreamAdapterTest, ClosingPipeCausesFatalError) {
-  std::vector<StopTrigger> errors;
-  demuxer_stream_adapter_->TakeErrors(&errors);
-  ASSERT_TRUE(errors.empty());
-
-  // Closes one end of mojo message and data pipes.
-  data_stream_sender_.reset();
-  RunPendingTasks();  // Allow notification from mojo to propagate.
-
-  demuxer_stream_adapter_->TakeErrors(&errors);
-  ASSERT_EQ(1u, errors.size());
-  EXPECT_EQ(MOJO_PIPE_ERROR, errors[0]);
-}
-
-}  // namesapce remoting
-}  // namespace media