media: Use associated interface for mojo RendererClient

media/mojo/clients/mojo_renderer.cc

 // Copyright 2014 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/mojo/clients/mojo_renderer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 10 matching lines @@
 
 MojoRenderer::MojoRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
     VideoRendererSink* video_renderer_sink,
     mojom::RendererPtr remote_renderer)
     : task_runner_(task_runner),
       video_overlay_factory_(std::move(video_overlay_factory)),
       video_renderer_sink_(video_renderer_sink),
       remote_renderer_info_(remote_renderer.PassInterface()),
-      binding_(this),
+      client_binding_(this),
       media_time_interpolator_(&media_clock_) {
   DVLOG(1) << __FUNCTION__;
 }
 
 MojoRenderer::~MojoRenderer() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   CancelPendingCallbacks();
 }
@@ skipping 55 matching lines @@
     // Using base::Unretained(this) is safe because |this| owns
     // |video_stream_|, and the error handler can't be invoked once
     // |video_stream_| is destroyed.
     video_stream_->set_connection_error_handler(
         base::Bind(&MojoRenderer::OnDemuxerStreamConnectionError,
                    base::Unretained(this), DemuxerStream::VIDEO));
   }
 
   BindRemoteRendererIfNeeded();
 
+  mojom::RendererClientAssociatedPtrInfo client_ptr_info;

[alokp, 2016/09/22 17:30:08]

move these two lines into BindRemoteRendererIfNeeded so that it is not repeated
in InitializeRendererFromUrl?

[xhwang, 2016/09/22 18:11:57]

I see the benefit of less code duplication. But really this is about binding the
"client ptr", not the "remote renderer". So it seems a wrong place to me.

[alokp, 2016/09/22 18:17:24]

Acknowledged.

+  client_binding_.Bind(&client_ptr_info, remote_renderer_.associated_group());
+
   // Using base::Unretained(this) is safe because |this| owns
   // |remote_renderer_|, and the callback won't be dispatched if
   // |remote_renderer_| is destroyed.
   remote_renderer_->Initialize(
-      binding_.CreateInterfacePtrAndBind(), std::move(audio_stream),
+      std::move(client_ptr_info), std::move(audio_stream),
       std::move(video_stream), base::nullopt,
       base::Bind(&MojoRenderer::OnInitialized, base::Unretained(this), client));
 }
 
 void MojoRenderer::InitializeRendererFromUrl(media::RendererClient* client) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   BindRemoteRendererIfNeeded();
 
+  mojom::RendererClientAssociatedPtrInfo client_ptr_info;
+  client_binding_.Bind(&client_ptr_info, remote_renderer_.associated_group());
+
   // Using base::Unretained(this) is safe because |this| owns
   // |remote_renderer_|, and the callback won't be dispatched if
   // |remote_renderer_| is destroyed.
   remote_renderer_->Initialize(
-      binding_.CreateInterfacePtrAndBind(), mojom::DemuxerStreamPtr(),
+      std::move(client_ptr_info), mojom::DemuxerStreamPtr(),
       mojom::DemuxerStreamPtr(), demuxer_stream_provider_->GetUrl(),
       base::Bind(&MojoRenderer::OnInitialized, base::Unretained(this), client));
 }
 
 void MojoRenderer::SetCdm(CdmContext* cdm_context,
                           const CdmAttachedCB& cdm_attached_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(cdm_context);
   DCHECK(!cdm_attached_cb.is_null());
@@ skipping 258 matching lines @@
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 
   if (!cdm_attached_cb_.is_null())
     base::ResetAndReturn(&cdm_attached_cb_).Run(false);
 }
 
 }  // namespace media