Media Remoting: Add remoting control logic for encrypted contents.

media/remoting/remote_renderer_impl.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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_keys.h"
 #include "media/remoting/remote_demuxer_stream_adapter.h"
-#include "media/remoting/remoting_controller.h"
+#include "media/remoting/remoting_renderer_controller.h"
 #include "media/remoting/rpc/proto_enum_utils.h"
 #include "media/remoting/rpc/proto_utils.h"
 
 namespace media {
 
 RemoteRendererImpl::RemoteRendererImpl(
     scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-    const base::WeakPtr<RemotingController>& remoting_controller)
+    const base::WeakPtr<RemotingRendererController>&
+        remoting_renderer_controller)
     : state_(STATE_UNINITIALIZED),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       media_task_runner_(std::move(media_task_runner)),
       demuxer_stream_provider_(nullptr),
       client_(nullptr),
-      remoting_controller_(remoting_controller),
-      rpc_broker_(remoting_controller_->GetRpcBroker()),
+      remoting_renderer_controller_(remoting_renderer_controller),
+      rpc_broker_(remoting_renderer_controller_->GetRpcBroker()),
       rpc_handle_(remoting::RpcBroker::GetUniqueHandle()),
       remote_renderer_handle_(remoting::kInvalidHandle),
       weak_factory_(this) {
   VLOG(2) << __FUNCTION__;
   // The constructor is running on the main thread.
-  DCHECK(remoting_controller);
+  DCHECK(remoting_renderer_controller);
   const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
       base::Bind(&RemoteRendererImpl::OnMessageReceivedOnMainThread,
                  media_task_runner_, weak_factory_.GetWeakPtr());
   rpc_broker_->RegisterMessageReceiverCallback(rpc_handle_, receive_callback);
 }
 
 RemoteRendererImpl::~RemoteRendererImpl() {
   VLOG(2) << __FUNCTION__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   // Post task on main thread to unregister message receiver.
@@ skipping 28 matching lines @@
 
   // Create video mojo data pipe handles if video is available.
   ::media::DemuxerStream* video_demuxer_stream =
       demuxer_stream_provider_->GetStream(::media::DemuxerStream::VIDEO);
   std::unique_ptr<mojo::DataPipe> video_data_pipe;
   if (video_demuxer_stream) {
     video_data_pipe = base::WrapUnique(remoting::CreateDataPipe());
   }
 
   // Establish remoting data pipe connection using main thread.
-  const RemotingController::DataPipeStartCallback data_pipe_callback =
+  const RemotingSourceImpl::DataPipeStartCallback data_pipe_callback =
       base::Bind(&RemoteRendererImpl::OnDataPipeCreatedOnMainThread,
                  media_task_runner_, weak_factory_.GetWeakPtr());
   main_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&RemotingController::StartDataPipe, remoting_controller_,
-                 base::Passed(&audio_data_pipe), base::Passed(&video_data_pipe),
-                 data_pipe_callback));
+      base::Bind(&RemotingRendererController::StartDataPipe,
+                 remoting_renderer_controller_, base::Passed(&audio_data_pipe),
+                 base::Passed(&video_data_pipe), data_pipe_callback));
 }
 
 void RemoteRendererImpl::SetCdm(CdmContext* cdm_context,
                                 const CdmAttachedCB& cdm_attached_cb) {
   VLOG(2) << __FUNCTION__ << " cdm_id:" << cdm_context->GetCdmId();
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // TODO(erickung): add implementation once Remote CDM implementation is done.
   // Right now it returns callback immediately.
   if (!cdm_attached_cb.is_null()) {
@@ skipping 451 matching lines @@
     return;
   }
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 
   // After OnError() returns, the pipeline may destroy |this|.
   client_->OnError(error);
 }
 }  // namespace media