Rename DemuxerStreamProvider into MediaResource

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/test/simple_test_tick_clock.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 197 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 76 matching lines @@
     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);
     OnReceivedRpc(std::move(rpc));
     RunPendingTasks();
   }
 
   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_;
   base::SimpleTestTickClock* clock_;  // Owned by |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_;
@@ skipping 265 matching lines @@
     ASSERT_FALSE(DidEncounterFatalError());  // Not enough measurements.
     IssueStatisticsUpdateRpc();
     clock_->Advance(base::TimeDelta::FromSeconds(1));
     RunPendingTasks();
   }
   ASSERT_TRUE(DidEncounterFatalError());
 }
 
 }  // namespace remoting
 }  // namespace media