Media Remoting: Add remoting control logic for encrypted contents.

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/run_loop.h"
 #include "media/base/pipeline_status.h"
 #include "media/remoting/fake_remoting_controller.h"
 #include "media/remoting/fake_remoting_demuxer_stream_provider.h"
-#include "media/remoting/remoting_controller.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 {
 
 namespace {
@@ skipping 92 matching lines @@
     ASSERT_TRUE(rpc->ParseFromArray(message->data(), message->size()));
     switch (rpc->proc()) {
       case remoting::pb::RpcMessage::RPC_ACQUIRE_RENDERER: {
         // Issues RPC_ACQUIRE_RENDERER_DONE RPC message.
         std::unique_ptr<remoting::pb::RpcMessage> acquire_done(
             new remoting::pb::RpcMessage());
         acquire_done->set_handle(rpc->integer_value());
         acquire_done->set_proc(
             remoting::pb::RpcMessage::RPC_ACQUIRE_RENDERER_DONE);
         acquire_done->set_integer_value(receiver_renderer_handle_);
-        remoting_controller_->GetRpcBroker()->ProcessMessageFromRemote(
+        remoting_renderer_controller_->GetRpcBroker()->ProcessMessageFromRemote(
             std::move(acquire_done));
       } break;
       case remoting::pb::RpcMessage::RPC_R_INITIALIZE: {
         EXPECT_EQ(rpc->handle(), receiver_renderer_handle_);
         sender_renderer_callback_handle_ =
             rpc->renderer_initialize_rpc().callback_handle();
         sender_client_handle_ = rpc->renderer_initialize_rpc().client_handle();
         sender_audio_demuxer_handle_ =
             rpc->renderer_initialize_rpc().audio_demuxer_handle();
         sender_video_demuxer_handle_ =
             rpc->renderer_initialize_rpc().video_demuxer_handle();
 
         // Issues audio RPC_DS_INITIALIZE RPC message.
         if (sender_audio_demuxer_handle_ != remoting::kInvalidHandle) {
           std::unique_ptr<remoting::pb::RpcMessage> ds_init(
               new remoting::pb::RpcMessage());
           ds_init->set_handle(sender_audio_demuxer_handle_);
           ds_init->set_proc(remoting::pb::RpcMessage::RPC_DS_INITIALIZE);
           ds_init->set_integer_value(receiver_audio_demuxer_callback_handle_);
-          remoting_controller_->GetRpcBroker()->ProcessMessageFromRemote(
-              std::move(ds_init));
+          remoting_renderer_controller_->GetRpcBroker()
+              ->ProcessMessageFromRemote(std::move(ds_init));
         }
         if (sender_video_demuxer_handle_ != remoting::kInvalidHandle) {
           std::unique_ptr<remoting::pb::RpcMessage> ds_init(
               new remoting::pb::RpcMessage());
           ds_init->set_handle(sender_video_demuxer_handle_);
           ds_init->set_proc(remoting::pb::RpcMessage::RPC_DS_INITIALIZE);
           ds_init->set_integer_value(receiver_video_demuxer_callback_handle_);
-          remoting_controller_->GetRpcBroker()->ProcessMessageFromRemote(
-              std::move(ds_init));
+          remoting_renderer_controller_->GetRpcBroker()
+              ->ProcessMessageFromRemote(std::move(ds_init));
         }
       } break;
       case remoting::pb::RpcMessage::RPC_DS_INITIALIZE_CALLBACK: {
         if (rpc->handle() == receiver_audio_demuxer_callback_handle_)
           received_audio_ds_init_cb_ = true;
         if (rpc->handle() == receiver_video_demuxer_callback_handle_)
           received_video_ds_init_cb_ = true;
 
         // Issues RPC_R_INITIALIZE_CALLBACK RPC message when receiving
         // RPC_DS_INITIALIZE_CALLBACK on available streams.
         if (received_audio_ds_init_cb_ ==
                 (sender_audio_demuxer_handle_ != remoting::kInvalidHandle) &&
             received_video_ds_init_cb_ ==
                 (sender_video_demuxer_handle_ != remoting::kInvalidHandle)) {
           std::unique_ptr<remoting::pb::RpcMessage> init_cb(
               new remoting::pb::RpcMessage());
           init_cb->set_handle(sender_renderer_callback_handle_);
           init_cb->set_proc(
               remoting::pb::RpcMessage::RPC_R_INITIALIZE_CALLBACK);
           init_cb->set_boolean_value(true);
-          remoting_controller_->GetRpcBroker()->ProcessMessageFromRemote(
-              std::move(init_cb));
+          remoting_renderer_controller_->GetRpcBroker()
+              ->ProcessMessageFromRemote(std::move(init_cb));
           renderer_initialized_ = true;
         }
 
       } break;
       case remoting::pb::RpcMessage::RPC_R_FLUSHUNTIL: {
         // Issues RPC_R_FLUSHUNTIL_CALLBACK RPC message.
         std::unique_ptr<remoting::pb::RpcMessage> flush_cb(
             new remoting::pb::RpcMessage());
         flush_cb->set_handle(rpc->renderer_flushuntil_rpc().callback_handle());
         flush_cb->set_proc(remoting::pb::RpcMessage::RPC_R_FLUSHUNTIL_CALLBACK);
-        remoting_controller_->GetRpcBroker()->ProcessMessageFromRemote(
+        remoting_renderer_controller_->GetRpcBroker()->ProcessMessageFromRemote(
             std::move(flush_cb));
 
       } break;
 
       default:
         NOTREACHED();
     }
     RunPendingTasks();
   }
 
   // Callback from RpcBroker when sending message to remote sink.
   void OnSendMessageToSink(std::unique_ptr<std::vector<uint8_t>> message) {
     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());
     EXPECT_CALL(*render_client_, OnPipelineStatus(_)).Times(1);
     DCHECK(remote_renderer_impl_);
     // Redirect RPC message for simulate receiver scenario
-    remoting_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
+    remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
         base::Bind(&RemoteRendererImplTest::RpcMessageResponseBot,
                    base::Unretained(this)));
     RunPendingTasks();
     remote_renderer_impl_->Initialize(
         demuxer_stream_provider_.get(), render_client_.get(),
         base::Bind(&RendererClientImpl::OnPipelineStatus,
                    base::Unretained(render_client_.get())));
     RunPendingTasks();
     // Redirect RPC message back to save for later check.
-    remoting_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
+    remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
         base::Bind(&RemoteRendererImplTest::OnSendMessageToSink,
                    base::Unretained(this)));
     RunPendingTasks();
   }
 
   bool IsRendererInitialized() const {
     return remote_renderer_impl_->state_ == RemoteRendererImpl::STATE_PLAYING;
   }
 
   void OnReceivedRpc(std::unique_ptr<remoting::pb::RpcMessage> message) {
     remote_renderer_impl_->OnReceivedRpc(std::move(message));
   }
 
   void SetUp() override {
-    // Creates RemotingController.
-    remoter_factory_.reset(new FakeRemoterFactory(true));
-    remoting_controller_ = CreateRemotingController(remoter_factory_.get());
+    // Creates RemotingRendererController.
+    remoting_renderer_controller_ =
+        base::MakeUnique<RemotingRendererController>(
+            CreateRemotingSourceImpl(false));
     // Redirect RPC message to RemoteRendererImplTest::OnSendMessageToSink().
-    remoting_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
+    remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
         base::Bind(&RemoteRendererImplTest::OnSendMessageToSink,
                    base::Unretained(this)));
 
     // Creates RemoteRendererImpl.
     remote_renderer_impl_.reset(
         new RemoteRendererImpl(base::ThreadTaskRunnerHandle::Get(),
-                               remoting_controller_->GetWeakPtr()));
+                               remoting_renderer_controller_->GetWeakPtr()));
     RunPendingTasks();
   }
 
   RemoteRendererImpl::State state() const {
     return remote_renderer_impl_->state_;
   }
 
   void RunPendingTasks() { base::RunLoop().RunUntilIdle(); }
 
   // Gets first available RpcMessage with specific |proc|.
   const remoting::pb::RpcMessage* PeekRpcMessage(int proc) const {
     for (auto& s : received_rpc_) {
       if (proc == s->proc())
         return s.get();
     }
     return nullptr;
   }
   int ReceivedRpcMessageCount() const { return received_rpc_.size(); }
   void ResetReceivedRpcMessage() { received_rpc_.clear(); }
 
   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);
   }
 
-  std::unique_ptr<FakeRemoterFactory> remoter_factory_;
-  std::unique_ptr<RemotingController> remoting_controller_;
+  std::unique_ptr<RemotingRendererController> remoting_renderer_controller_;
   std::unique_ptr<RendererClientImpl> render_client_;
   std::unique_ptr<FakeRemotingDemuxerStreamProvider> demuxer_stream_provider_;
   std::unique_ptr<RemoteRendererImpl> remote_renderer_impl_;
   base::MessageLoop message_loop_;
 
   // 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_;
@@ skipping 25 matching lines @@
 
 TEST_F(RemoteRendererImplTest, Flush) {
   // Initialize Renderer.
   InitializeRenderer();
   RunPendingTasks();
   ASSERT_TRUE(IsRendererInitialized());
   ASSERT_EQ(render_client_->status(), PIPELINE_OK);
 
   // Flush Renderer.
   // Redirect RPC message for simulate receiver scenario
-  remoting_controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
-      &RemoteRendererImplTest::RpcMessageResponseBot, base::Unretained(this)));
+  remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
+      base::Bind(&RemoteRendererImplTest::RpcMessageResponseBot,
+                 base::Unretained(this)));
   RunPendingTasks();
   EXPECT_CALL(*render_client_, OnFlushCallback()).Times(1);
   remote_renderer_impl_->Flush(
       base::Bind(&RendererClientImpl::OnFlushCallback,
                  base::Unretained(render_client_.get())));
   RunPendingTasks();
 }
 
 TEST_F(RemoteRendererImplTest, StartPlayingFrom) {
   // Initialize Renderer
@@ skipping 33 matching lines @@
 TEST_F(RemoteRendererImplTest, SetPlaybackRate) {
   // Without initializing renderer, SetPlaybackRate() will be no-op.
   remote_renderer_impl_->SetPlaybackRate(-1.5);
   RunPendingTasks();
   ASSERT_EQ(0, ReceivedRpcMessageCount());
 
   // Initialize Renderer
   InitializeRenderer();
   RunPendingTasks();
 
-  remoting_controller_->GetRpcBroker()->SetMessageCallbackForTesting(base::Bind(
-      &RemoteRendererImplTest::OnSendMessageToSink, base::Unretained(this)));
+  remoting_renderer_controller_->GetRpcBroker()->SetMessageCallbackForTesting(
+      base::Bind(&RemoteRendererImplTest::OnSendMessageToSink,
+                 base::Unretained(this)));
   remote_renderer_impl_->SetPlaybackRate(2.5);
   RunPendingTasks();
   ASSERT_EQ(1, ReceivedRpcMessageCount());
   // Checks if it sends out RPC message with correct value.
   const remoting::pb::RpcMessage* rpc =
       PeekRpcMessage(remoting::pb::RpcMessage::RPC_R_SETPLAYBACKRATE);
   ASSERT_TRUE(rpc);
   ASSERT_TRUE(rpc->double_value() == 2.5);
 }
 
@@ skipping 147 matching lines @@
   // Issues RPC_RC_ONDURATIONCHANGE RPC message.
   EXPECT_CALL(*render_client_, OnDurationChange(_)).Times(0);
   std::unique_ptr<remoting::pb::RpcMessage> rpc(new remoting::pb::RpcMessage());
   rpc->set_handle(5);
   rpc->set_proc(remoting::pb::RpcMessage::RPC_RC_ONDURATIONCHANGE);
   rpc->set_integer64_value(-345);
   OnReceivedRpc(std::move(rpc));
   RunPendingTasks();
 }
 }  // namespace media