MediaResource refactoring to support multiple streams

media/remoting/courier_renderer_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/courier_renderer.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/renderer_client.h"
 #include "media/base/test_helpers.h"
-#include "media/remoting/fake_demuxer_stream_provider.h"
+#include "media/remoting/fake_media_resource.h"
 #include "media/remoting/fake_remoter.h"
 #include "media/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 180 matching lines @@
   void OnSendMessageToSink(std::unique_ptr<std::vector<uint8_t>> message) {
     std::unique_ptr<pb::RpcMessage> rpc(new 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 FakeDemuxerStreamProvider());
+    media_resource_.reset(new FakeMediaResource());
     EXPECT_CALL(*render_client_, OnPipelineStatus(_)).Times(1);
     DCHECK(renderer_);
     // Redirect RPC message for simulate receiver scenario
     controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
         &CourierRendererTest::RpcMessageResponseBot, base::Unretained(this)));
     RunPendingTasks();
-    renderer_->Initialize(demuxer_stream_provider_.get(), render_client_.get(),
+    renderer_->Initialize(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.
     controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
         &CourierRendererTest::OnSendMessageToSink, base::Unretained(this)));
     RunPendingTasks();
   }
 
   bool IsRendererInitialized() const {
@@ skipping 35 matching lines @@
 
   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);
   }
 
   base::MessageLoop message_loop_;
   std::unique_ptr<RendererController> controller_;
   std::unique_ptr<RendererClientImpl> render_client_;
-  std::unique_ptr<FakeDemuxerStreamProvider> demuxer_stream_provider_;
+  std::unique_ptr<FakeMediaResource> media_resource_;
   std::unique_ptr<CourierRenderer> renderer_;
 
   // 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 247 matching lines @@
   rpc->set_proc(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 remoting
 }  // namespace media