Add support for external video renderers in mojo.

media/mojo/services/mojo_demuxer_stream_adapter.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/services/mojo_demuxer_stream_adapter.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "media/base/decoder_buffer.h"
 #include "media/mojo/services/media_type_converters.h"
 
 namespace media {
 
 MojoDemuxerStreamAdapter::MojoDemuxerStreamAdapter(
     mojo::DemuxerStreamPtr demuxer_stream,
-    const base::Closure& stream_ready_cb)
+    const base::Closure& stream_ready_cb,
+    DemuxerStream::Type type)

[xhwang, 2014/10/29 00:22:13]

Can we drop this |type| param and populate |type_| in
OnAudioDecoderConfigChanged() and OnVideoDecoderConfigChanged()?

We won't return the stream_ready_cb before we have a valid config (thus a type),
so it should be safe.

I like this better because this way we don't need to pass in the type in
MojoDemuxerStreamAdapter's ctor. This will make DemuxerStreamProviderShim::ctor
cleaner, especially in the future when we use Array(DemuxerStreamPtr).

[DaleCurtis, 2014/10/30 23:16:56]

Done.

     : demuxer_stream_(demuxer_stream.Pass()),
       stream_ready_cb_(stream_ready_cb),
+      type_(type),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
   demuxer_stream_.set_client(this);
 }
 
 MojoDemuxerStreamAdapter::~MojoDemuxerStreamAdapter() {
   DVLOG(1) << __FUNCTION__;
 }
 
 void MojoDemuxerStreamAdapter::Read(const DemuxerStream::ReadCB& read_cb) {
   DVLOG(3) << __FUNCTION__;
   // We shouldn't be holding on to a previous callback if a new Read() came in.
   DCHECK(read_cb_.is_null());
   read_cb_ = read_cb;
   demuxer_stream_->Read(base::Bind(&MojoDemuxerStreamAdapter::OnBufferReady,
                                    weak_factory_.GetWeakPtr()));
 }
 
 AudioDecoderConfig MojoDemuxerStreamAdapter::audio_decoder_config() {
-  DCHECK(!config_queue_.empty());
-  return config_queue_.front();
+  DCHECK_EQ(type_, DemuxerStream::AUDIO);
+  DCHECK(!audio_config_queue_.empty());
+  return audio_config_queue_.front();
 }
 
 VideoDecoderConfig MojoDemuxerStreamAdapter::video_decoder_config() {
-  NOTREACHED();
-  return VideoDecoderConfig();
+  DCHECK_EQ(type_, DemuxerStream::VIDEO);
+  DCHECK(!video_config_queue_.empty());
+  return video_config_queue_.front();
 }
 
-media::DemuxerStream::Type MojoDemuxerStreamAdapter::type() {
-  return media::DemuxerStream::AUDIO;
+DemuxerStream::Type MojoDemuxerStreamAdapter::type() {
+  return type_;
 }
 
 void MojoDemuxerStreamAdapter::EnableBitstreamConverter() {
-  NOTREACHED();
+  NOTIMPLEMENTED();
 }
 
 bool MojoDemuxerStreamAdapter::SupportsConfigChanges() {
   return true;
 }
 
 VideoRotation MojoDemuxerStreamAdapter::video_rotation() {
   NOTIMPLEMENTED();
   return VIDEO_ROTATION_0;
 }
 
 void MojoDemuxerStreamAdapter::OnStreamReady(
     mojo::ScopedDataPipeConsumerHandle pipe) {
   DVLOG(1) << __FUNCTION__;
   // TODO(tim): We don't support pipe streaming yet.
   DCHECK(!pipe.is_valid());
-  DCHECK(!config_queue_.empty());
+  if (type_ == DemuxerStream::AUDIO)
+    DCHECK(!audio_config_queue_.empty());
+  if (type_ == DemuxerStream::VIDEO)
+    DCHECK(!video_config_queue_.empty());

[xhwang, 2014/10/29 00:22:13]

Some clean up idea for the future. We have both audio and video code in this
class which results in a lot of duplicate code. Maybe we can make
MojoDemuxerStreamAdapter a templated class based on Type, as we did for
DecoderStream.

[DaleCurtis, 2014/10/30 23:16:56]

Maybe, that's the opposite of what you're suggesting above though... at least
without having some sort of inner class which is templated appropriately for
each.

[xhwang, 2014/10/31 03:25:57]

Yeah, I just felt that'd be something nice. But honestly I don't know how to do
that yet :)

   stream_ready_cb_.Run();
 }
 
 void MojoDemuxerStreamAdapter::OnAudioDecoderConfigChanged(
     mojo::AudioDecoderConfigPtr config) {
-  config_queue_.push(config.To<media::AudioDecoderConfig>());
+  audio_config_queue_.push(config.To<AudioDecoderConfig>());
 
   if (!read_cb_.is_null()) {
-    read_cb_.Run(media::DemuxerStream::Status::kConfigChanged, NULL);
+    read_cb_.Run(DemuxerStream::Status::kConfigChanged, NULL);
     read_cb_.Reset();
   }
 }
+
+void MojoDemuxerStreamAdapter::OnVideoDecoderConfigChanged(
+    mojo::VideoDecoderConfigPtr config) {
+  video_config_queue_.push(config.To<VideoDecoderConfig>());
+
+  if (!read_cb_.is_null()) {
+    read_cb_.Run(DemuxerStream::Status::kConfigChanged, NULL);
+    read_cb_.Reset();
+  }
+}
 
 void MojoDemuxerStreamAdapter::OnBufferReady(
     mojo::DemuxerStream::Status status,
     mojo::MediaDecoderBufferPtr buffer) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(!read_cb_.is_null());
-  DCHECK(!config_queue_.empty());
+  if (type_ == DemuxerStream::AUDIO)
+    DCHECK(!audio_config_queue_.empty());
+  if (type_ == DemuxerStream::VIDEO)
+    DCHECK(!video_config_queue_.empty());
 
-  media::DemuxerStream::Status media_status(
-      static_cast<media::DemuxerStream::Status>(status));
-  scoped_refptr<media::DecoderBuffer> media_buffer(
-      buffer.To<scoped_refptr<media::DecoderBuffer> >());
+  DemuxerStream::Status media_status(
+      static_cast<DemuxerStream::Status>(status));
+  scoped_refptr<DecoderBuffer> media_buffer(
+      buffer.To<scoped_refptr<DecoderBuffer> >());
 
   if (status == mojo::DemuxerStream::STATUS_CONFIG_CHANGED) {
     DCHECK(!media_buffer.get());
-    config_queue_.pop();
 
-    // If the |config_queue_| is empty we need to wait for
-    // OnAudioDecoderConfigChanged before invoking |read_cb|.
-    if (config_queue_.empty())
-      return;
+    if (type_ == DemuxerStream::AUDIO) {
+      audio_config_queue_.pop();
+
+      // If the |config_queue_| is empty we need to wait for
+      // OnAudioDecoderConfigChanged before invoking |read_cb|.
+      if (audio_config_queue_.empty())
+        return;
+    }
+    if (type_ == DemuxerStream::VIDEO) {
+      video_config_queue_.pop();
+
+      // If the |config_queue_| is empty we need to wait for
+      // OnAudioDecoderConfigChanged before invoking |read_cb|.
+      if (video_config_queue_.empty())
+        return;
+    }
   }
   read_cb_.Run(media_status, media_buffer);
   read_cb_.Reset();
 }
 
 }  // namespace media