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

media/remoting/demuxer_stream_adapter_unittest.cc

Index: media/remoting/demuxer_stream_adapter_unittest.cc
diff --git a/media/remoting/remote_demuxer_stream_adapter_unittest.cc b/media/remoting/demuxer_stream_adapter_unittest.cc
similarity index 81%
rename from media/remoting/remote_demuxer_stream_adapter_unittest.cc
rename to media/remoting/demuxer_stream_adapter_unittest.cc
index 26ac2dedd0ad5f3f7e40b3edf1f6eaf216956809..22c60e44b8740a368b233d43b22840a4b2e2bac5 100644
--- a/media/remoting/remote_demuxer_stream_adapter_unittest.cc
+++ b/media/remoting/demuxer_stream_adapter_unittest.cc
@@ -2,7 +2,7 @@
 // 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 "media/remoting/demuxer_stream_adapter.h"
 
 #include <memory>
 #include <vector>
@@ -11,9 +11,9 @@
 #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 "media/remoting/fake_demuxer_stream_provider.h"
+#include "media/remoting/fake_remoter.h"
+#include "media/remoting/proto_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -24,39 +24,39 @@ using testing::Return;
 namespace media {
 namespace remoting {
 
-class MockRemoteDemuxerStreamAdapter {
+class MockDemuxerStreamAdapter {
  public:
-  MockRemoteDemuxerStreamAdapter(
+  MockDemuxerStreamAdapter(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
       const std::string& name,
-      ::media::DemuxerStream* demuxer_stream,
+      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(
+    rpc_broker_.reset(
+        new RpcBroker(base::Bind(&MockDemuxerStreamAdapter::OnSendMessageToSink,
+                                 weak_factory_.GetWeakPtr())));
+    demuxer_stream_adapter_.reset(new DemuxerStreamAdapter(
         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,
+        base::Bind(&MockDemuxerStreamAdapter::OnError,
                    weak_factory_.GetWeakPtr())));
 
     // Faking initialization with random callback handle to start mojo watcher.
     demuxer_stream_adapter_->Initialize(3);
   }
 
-  ~MockRemoteDemuxerStreamAdapter() {
+  ~MockDemuxerStreamAdapter() {
     // 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() {
+  base::WeakPtr<MockDemuxerStreamAdapter> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
@@ -79,7 +79,7 @@ class MockRemoteDemuxerStreamAdapter {
 
     demuxer_stream_adapter_->OnReceivedRpc(std::move(rpc));
   }
-  void OnNewBuffer(const scoped_refptr<::media::DecoderBuffer>& frame) {
+  void OnNewBuffer(const scoped_refptr<DecoderBuffer>& frame) {
     demuxer_stream_adapter_->OnNewBuffer(DemuxerStream::kOk, frame);
   }
 
@@ -89,31 +89,31 @@ class MockRemoteDemuxerStreamAdapter {
 
  private:
   void OnSendMessageToSink(std::unique_ptr<std::vector<uint8_t>> message) {
-    last_received_rpc_.reset(new remoting::pb::RpcMessage());
+    last_received_rpc_.reset(new 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::unique_ptr<DemuxerStreamAdapter> demuxer_stream_adapter_;
+  std::unique_ptr<pb::RpcMessage> last_received_rpc_;
 
   std::vector<StopTrigger> errors_;
 
-  base::WeakPtrFactory<MockRemoteDemuxerStreamAdapter> weak_factory_;
+  base::WeakPtrFactory<MockDemuxerStreamAdapter> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockRemoteDemuxerStreamAdapter);
+  DISALLOW_COPY_AND_ASSIGN(MockDemuxerStreamAdapter);
 };
 
-class RemoteDemuxerStreamAdapterTest : public ::testing::Test {
+class DemuxerStreamAdapterTest : public ::testing::Test {
  public:
-  RemoteDemuxerStreamAdapterTest() {}
-  ~RemoteDemuxerStreamAdapterTest() override = default;
+  DemuxerStreamAdapterTest() {}
+  ~DemuxerStreamAdapterTest() override = default;
 
   void SetUpDataPipe() {
     constexpr size_t kDataPipeCapacity = 256;
-    demuxer_stream_.reset(new DummyDemuxerStream(true));  // audio.
+    demuxer_stream_.reset(new FakeDemuxerStream(true));  // audio.
     const MojoCreateDataPipeOptions data_pipe_options{
         sizeof(MojoCreateDataPipeOptions),
         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, 1, kDataPipeCapacity};
@@ -126,11 +126,11 @@ class RemoteDemuxerStreamAdapterTest : public ::testing::Test {
 
     data_stream_sender_.reset(new FakeRemotingDataStreamSender(
         MakeRequest(&stream_sender), std::move(consumer_end)));
-    demuxer_stream_adapter_.reset(new MockRemoteDemuxerStreamAdapter(
+    demuxer_stream_adapter_.reset(new MockDemuxerStreamAdapter(
         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
+    // DemuxerStreamAdapter constructor posts task to main thread to
     // register MessageReceiverCallback. Therefore it should call
     // RunPendingTasks() to make sure task is executed.
     RunPendingTasks();
@@ -145,15 +145,15 @@ class RemoteDemuxerStreamAdapterTest : public ::testing::Test {
 
   // TODO(miu): Add separate media thread, to test threading also.
   base::MessageLoop message_loop_;
-  std::unique_ptr<DummyDemuxerStream> demuxer_stream_;
+  std::unique_ptr<FakeDemuxerStream> demuxer_stream_;
   std::unique_ptr<FakeRemotingDataStreamSender> data_stream_sender_;
-  std::unique_ptr<MockRemoteDemuxerStreamAdapter> demuxer_stream_adapter_;
+  std::unique_ptr<MockDemuxerStreamAdapter> demuxer_stream_adapter_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(RemoteDemuxerStreamAdapterTest);
+  DISALLOW_COPY_AND_ASSIGN(DemuxerStreamAdapterTest);
 };
 
-TEST_F(RemoteDemuxerStreamAdapterTest, SingleReadUntil) {
+TEST_F(DemuxerStreamAdapterTest, SingleReadUntil) {
   // Read will be called once since it doesn't return frame buffer in the dummy
   // implementation.
   EXPECT_CALL(*demuxer_stream_, Read(_)).Times(1);
@@ -162,7 +162,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, SingleReadUntil) {
   RunPendingTasks();
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, MultiReadUntil) {
+TEST_F(DemuxerStreamAdapterTest, 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);
@@ -174,7 +174,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, MultiReadUntil) {
   RunPendingTasks();
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameSmallerThanCapacity) {
+TEST_F(DemuxerStreamAdapterTest, 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);
@@ -191,7 +191,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameSmallerThanCapacity) {
   data_stream_sender_->ResetHistory();
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameLargerThanCapacity) {
+TEST_F(DemuxerStreamAdapterTest, 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);
@@ -208,7 +208,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, WriteOneFrameLargerThanCapacity) {
   data_stream_sender_->ResetHistory();
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, SendFrameAndSignalFlushMix) {
+TEST_F(DemuxerStreamAdapterTest, 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).
@@ -269,7 +269,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, SendFrameAndSignalFlushMix) {
   data_stream_sender_->ResetHistory();
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, DuplicateInitializeCausesFatalError) {
+TEST_F(DemuxerStreamAdapterTest, DuplicateInitializeCausesFatalError) {
   std::vector<StopTrigger> errors;
   demuxer_stream_adapter_->TakeErrors(&errors);
   ASSERT_TRUE(errors.empty());
@@ -280,7 +280,7 @@ TEST_F(RemoteDemuxerStreamAdapterTest, DuplicateInitializeCausesFatalError) {
   EXPECT_EQ(PEERS_OUT_OF_SYNC, errors[0]);
 }
 
-TEST_F(RemoteDemuxerStreamAdapterTest, ClosingPipeCausesFatalError) {
+TEST_F(DemuxerStreamAdapterTest, ClosingPipeCausesFatalError) {
   std::vector<StopTrigger> errors;
   demuxer_stream_adapter_->TakeErrors(&errors);
   ASSERT_TRUE(errors.empty());