Motown: Define MediaRenderer and make it the way we identify renderers.

services/media/factory_service/media_player_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 "base/logging.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/services/media/common/cpp/timeline.h"
 #include "services/media/factory_service/media_player_impl.h"
 #include "services/media/framework/parts/reader.h"
 #include "services/media/framework/util/callback_joiner.h"
 
 namespace mojo {
 namespace media {
 
 // static
 std::shared_ptr<MediaPlayerImpl> MediaPlayerImpl::Create(
     InterfaceHandle<SeekingReader> reader,
+    InterfaceHandle<MediaRenderer> audio_renderer,
+    InterfaceHandle<MediaRenderer> video_renderer,
     InterfaceRequest<MediaPlayer> request,
     MediaFactoryService* owner) {
   return std::shared_ptr<MediaPlayerImpl>(
-      new MediaPlayerImpl(reader.Pass(), request.Pass(), owner));
+      new MediaPlayerImpl(reader.Pass(), audio_renderer.Pass(),
+                          video_renderer.Pass(), request.Pass(), owner));
 }
 
 MediaPlayerImpl::MediaPlayerImpl(InterfaceHandle<SeekingReader> reader,
+                                 InterfaceHandle<MediaRenderer> audio_renderer,
+                                 InterfaceHandle<MediaRenderer> video_renderer,
                                  InterfaceRequest<MediaPlayer> request,
                                  MediaFactoryService* owner)
     : MediaFactoryService::Product<MediaPlayer>(this, request.Pass(), owner) {
   DCHECK(reader);
 
   status_publisher_.SetCallbackRunner([this](const GetStatusCallback& callback,
                                              uint64_t version) {
     MediaPlayerStatusPtr status = MediaPlayerStatus::New();
     status->timeline_transform = TimelineTransform::From(timeline_function_);
     status->end_of_stream = end_of_stream_;
     status->metadata = metadata_.Clone();
     callback.Run(version, status.Pass());
   });
 
   state_ = State::kWaiting;
 
   ConnectToService(owner->shell(), "mojo:media_factory", GetProxy(&factory_));
 
   factory_->CreateDemux(reader.Pass(), GetProxy(&demux_));
   HandleDemuxMetadataUpdates();
 
   factory_->CreateTimelineController(GetProxy(&timeline_controller_));
   timeline_controller_->GetControlSite(GetProxy(&timeline_control_site_));
   timeline_control_site_->GetTimelineConsumer(GetProxy(&timeline_consumer_));
   HandleTimelineControlSiteStatusUpdates();
 
+  audio_renderer_ = audio_renderer.Pass();
+  video_renderer_ = video_renderer.Pass();
+
   demux_->Describe([this](mojo::Array<MediaTypePtr> stream_types) {
     // Populate streams_ and enable the streams we want.
     std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
     for (MediaTypePtr& stream_type : stream_types) {
       streams_.push_back(std::unique_ptr<Stream>(new Stream()));
       Stream& stream = *streams_.back();
       switch (stream_type->medium) {
         case MediaTypeMedium::AUDIO:
+          stream.renderer_ = audio_renderer_.Pass();
           PrepareStream(&stream, streams_.size() - 1, stream_type,
-                        "mojo:audio_server", callback_joiner->NewCallback());
+                        callback_joiner->NewCallback());
           break;
         case MediaTypeMedium::VIDEO:
-          // TODO(dalesat): Send video somewhere.
-          PrepareStream(&stream, streams_.size() - 1, stream_type, "nowhere",
+          stream.renderer_ = video_renderer_.Pass();
+          PrepareStream(&stream, streams_.size() - 1, stream_type,
                         callback_joiner->NewCallback());
           break;
         // TODO(dalesat): Enable other stream types.
         default:
           break;
       }
     }
 
     callback_joiner->WhenJoined([this]() {
       // The enabled streams are prepared.
@@ skipping 110 matching lines @@
 }
 
 void MediaPlayerImpl::Seek(int64_t position) {
   target_position_ = position;
   Update();
 }
 
 void MediaPlayerImpl::PrepareStream(Stream* stream,
                                     size_t index,
                                     const MediaTypePtr& input_media_type,
-                                    const String& url,
                                     const std::function<void()>& callback) {
   DCHECK(factory_);
 
   demux_->GetProducer(index, GetProxy(&stream->encoded_producer_));
 
   if (input_media_type->encoding != MediaType::kAudioEncodingLpcm &&
       input_media_type->encoding != MediaType::kVideoEncodingUncompressed) {
     std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
     // Compressed media. Insert a decoder in front of the sink. The sink would
     // add its own internal decoder, but we want to test the decoder.
     factory_->CreateDecoder(input_media_type.Clone(),
                             GetProxy(&stream->decoder_));
 
     MediaConsumerPtr decoder_consumer;
     stream->decoder_->GetConsumer(GetProxy(&decoder_consumer));
 
     callback_joiner->Spawn();
     stream->encoded_producer_->Connect(decoder_consumer.Pass(),
                                        [stream, callback_joiner]() {
                                          stream->encoded_producer_.reset();
                                          callback_joiner->Complete();
                                        });
 
     callback_joiner->Spawn();
     stream->decoder_->GetOutputType(
-        [this, stream, url, callback_joiner](MediaTypePtr output_type) {
+        [this, stream, callback_joiner](MediaTypePtr output_type) {
           stream->decoder_->GetProducer(GetProxy(&stream->decoded_producer_));
-          CreateSink(stream, output_type, url, callback_joiner->NewCallback());
+          CreateSink(stream, output_type, callback_joiner->NewCallback());
           callback_joiner->Complete();
         });
 
     callback_joiner->WhenJoined(callback);
   } else {
     // Uncompressed media. Connect the demux stream directly to the sink. This
     // would work for compressed media as well (the sink would decode), but we
     // want to test the decoder.
     stream->decoded_producer_ = stream->encoded_producer_.Pass();
-    CreateSink(stream, input_media_type, url, callback);
+    CreateSink(stream, input_media_type, callback);
   }
 }
 
 void MediaPlayerImpl::CreateSink(Stream* stream,
                                  const MediaTypePtr& input_media_type,
-                                 const String& url,
                                  const std::function<void()>& callback) {
   DCHECK(input_media_type);
   DCHECK(stream->decoded_producer_);
   DCHECK(factory_);
 
-  factory_->CreateSink(url, input_media_type.Clone(), GetProxy(&stream->sink_));
+  factory_->CreateSink(stream->renderer_.Pass(), input_media_type.Clone(),
+                       GetProxy(&stream->sink_));
 
   MediaTimelineControlSitePtr timeline_control_site;
   stream->sink_->GetTimelineControlSite(GetProxy(&timeline_control_site));
 
   timeline_controller_->AddControlSite(timeline_control_site.Pass());
 
   MediaConsumerPtr consumer;
   stream->sink_->GetConsumer(GetProxy(&consumer));
 
   stream->decoded_producer_->Connect(consumer.Pass(),
@@ skipping 32 matching lines @@
         HandleTimelineControlSiteStatusUpdates(version, status.Pass());
       });
 }
 
 MediaPlayerImpl::Stream::Stream() {}
 
 MediaPlayerImpl::Stream::~Stream() {}
 
 }  // namespace media
 }  // namespace mojo