MediaResource refactoring to support multiple streams

media/remoting/remote_renderer_impl_unittest.cc

 // 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_renderer_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/test_helpers.h"
 #include "media/remoting/fake_remoting_controller.h"
-#include "media/remoting/fake_remoting_demuxer_stream_provider.h"
+#include "media/remoting/fake_remoting_media_resource.h"
 #include "media/remoting/remoting_renderer_controller.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 {
 
@@ skipping 187 matching lines @@
     std::unique_ptr<remoting::pb::RpcMessage> rpc(
         new remoting::pb::RpcMessage());
     ASSERT_TRUE(rpc->ParseFromArray(message->data(), message->size()));
     received_rpc_.push_back(std::move(rpc));
   }
 
  protected:
   void InitializeRenderer() {
     // Register media::RendererClient implementation.
     render_client_.reset(new RendererClientImpl());
-    demuxer_stream_provider_.reset(new FakeRemotingDemuxerStreamProvider());
+    media_resource_.reset(new FakeRemotingMediaResource());
     EXPECT_CALL(*render_client_, OnPipelineStatus(_)).Times(1);
     DCHECK(remote_renderer_impl_);
     // Redirect RPC message for simulate receiver scenario
     remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
         base::Bind(&RemoteRendererImplTest::RpcMessageResponseBot,
                    base::Unretained(this)));
     RunPendingTasks();
     remote_renderer_impl_->Initialize(
-        demuxer_stream_provider_.get(), render_client_.get(),
+        media_resource_.get(), render_client_.get(),
         base::Bind(&RendererClientImpl::OnPipelineStatus,
                    base::Unretained(render_client_.get())));
     RunPendingTasks();
     // Redirect RPC message back to save for later check.
     remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
         base::Bind(&RemoteRendererImplTest::OnSendMessageToSink,
                    base::Unretained(this)));
     RunPendingTasks();
   }
 
@@ skipping 43 matching lines @@
 
   void ValidateCurrentTime(base::TimeDelta current,
                            base::TimeDelta current_max) const {
     ASSERT_EQ(remote_renderer_impl_->current_media_time_, current);
     ASSERT_EQ(remote_renderer_impl_->current_max_time_, current_max);
   }
 
   base::MessageLoop message_loop_;
   std::unique_ptr<RemotingRendererController> remoting_renderer_controller_;
   std::unique_ptr<RendererClientImpl> render_client_;
-  std::unique_ptr<FakeRemotingDemuxerStreamProvider> demuxer_stream_provider_;
+  std::unique_ptr<FakeRemotingMediaResource> media_resource_;
   std::unique_ptr<RemoteRendererImpl> remote_renderer_impl_;
 
   // RPC handles.
   const int receiver_renderer_handle_;
   const int receiver_audio_demuxer_callback_handle_;
   const int receiver_video_demuxer_callback_handle_;
   int sender_client_handle_;
   int sender_renderer_callback_handle_;
   int sender_audio_demuxer_handle_;
   int sender_video_demuxer_handle_;
@@ skipping 253 matching lines @@
   rpc->set_handle(5);
   rpc->set_proc(remoting::pb::RpcMessage::RPC_RC_ONDURATIONCHANGE);
   rpc->set_integer64_value(-345);
   OnReceivedRpc(std::move(rpc));
   RunPendingTasks();
 }
 
 // TODO(xjz): Tests for detecting PACING_TOO_SLOWLY and FRAME_DROP_RATE_HIGH.
 
 }  // namespace media