[DO NOT COMMIT] Initial MediaPlayerRenderer plumbing and basic features

media/mojo/clients/mojo_renderer_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/renderer_client.h"
 #include "media/base/video_renderer_sink.h"
+#include "media/media_features.h"
 #include "media/mojo/clients/mojo_demuxer_stream_impl.h"
 #include "media/renderers/video_overlay_factory.h"
+#include "mojo/common/url_type_converters.h"
 
 namespace media {
 
 MojoRendererImpl::MojoRendererImpl(
     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) {
+      binding_(this),
+      surface_id_(-1) {
   DVLOG(1) << __FUNCTION__;
 }
 
 MojoRendererImpl::~MojoRendererImpl() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void MojoRendererImpl::Initialize(
     DemuxerStreamProvider* demuxer_stream_provider,
     media::RendererClient* client,
     const PipelineStatusCB& init_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(demuxer_stream_provider);
 
   demuxer_stream_provider_ = demuxer_stream_provider;
   client_ = client;
   init_cb_ = init_cb;
 
+  if (!request_surface_cb_.is_null()) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(request_surface_cb_,
+                              base::Bind(&MojoRendererImpl::OnSurfaceCreated,
+                                         base::Unretained(this))));
+  } else {
+    InitializeRenderer();
+  }
+}
+
+void MojoRendererImpl::InitializeRenderer() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
   // Create audio and video mojom::DemuxerStream and bind its lifetime to
   // the pipe.
   DemuxerStream* const audio =
       demuxer_stream_provider_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* const video =
       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO);
 
   mojom::DemuxerStreamPtr audio_stream;
   if (audio)
     new MojoDemuxerStreamImpl(audio, GetProxy(&audio_stream));
 
   mojom::DemuxerStreamPtr video_stream;
   if (video)
     new MojoDemuxerStreamImpl(video, GetProxy(&video_stream));
 
   BindRemoteRendererIfNeeded();
 
   // 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(video_stream),
+      std::move(video_stream), mojo::String::From(url_), surface_id_,
       base::Bind(&MojoRendererImpl::OnInitialized, base::Unretained(this)));
 }
 
+void MojoRendererImpl::OnSurfaceCreated(int surface_id) {
+  DVLOG(2) << __FUNCTION__;
+
+  surface_id_ = surface_id;
+
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&MojoRendererImpl::InitializeRenderer,
+                                    base::Unretained(this)));
+}
+
 void MojoRendererImpl::SetCdm(CdmContext* cdm_context,
                               const CdmAttachedCB& cdm_attached_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(cdm_context);
 
   int32_t cdm_id = cdm_context->GetCdmId();
   if (cdm_id == CdmContext::kInvalidCdmId) {
     DVLOG(2) << "MojoRendererImpl only works with remote CDMs but the CDM ID "
                 "is invalid.";
@@ skipping 85 matching lines @@
 
   // TODO(tim): Should we plumb error code from remote renderer?
   // http://crbug.com/410451.
   client_->OnError(PIPELINE_ERROR_DECODE);
 }
 
 void MojoRendererImpl::OnVideoNaturalSizeChange(const gfx::Size& size) {
   DVLOG(2) << __FUNCTION__ << ": " << size.ToString();
   DCHECK(task_runner_->BelongsToCurrentThread());
 
+#if !BUILDFLAG(FORCE_MOJO_MEDIA_PLAYER_RENDERER)
+  // TODO(tguilbert): Investigate why this line crashes when using the
+  // MediaPlayerRenderer.
   video_renderer_sink_->PaintSingleFrame(
       video_overlay_factory_->CreateFrame(size));
+#endif
+
   client_->OnVideoNaturalSizeChange(size);
 }
 
+void MojoRendererImpl::OnDurationChange(int64_t duration_usec) {
+  DVLOG(2) << __FUNCTION__ << ": duration" << duration_usec;
+  client_->OnDurationChange(base::TimeDelta::FromMicroseconds(duration_usec));
+}
+
 void MojoRendererImpl::OnVideoOpacityChange(bool opaque) {
   DVLOG(2) << __FUNCTION__ << ": " << opaque;
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 void MojoRendererImpl::OnConnectionError() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 26 matching lines @@
 
 void MojoRendererImpl::OnInitialized(bool success) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!init_cb_.is_null());
 
   base::ResetAndReturn(&init_cb_).Run(
       success ? PIPELINE_OK : PIPELINE_ERROR_INITIALIZATION_FAILED);
 }
 
+#if defined(OS_ANDROID)
+void MojoRendererImpl::SetUrl(const GURL& url) {
+  url_ = url;
+}
+
+void MojoRendererImpl::SetRequestSurfaceCB(
+    const RequestSurfaceCB& request_surface_cb) {
+  request_surface_cb_ = request_surface_cb;
+}
+#endif
+
 }  // namespace media