Motown: Change media type (stream type) representation

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 "services/media/factory_service/media_player_impl.h"
 #include "services/media/framework/callback_joiner.h"
 #include "services/media/framework/parts/reader.h"
 
 namespace mojo {
@@ skipping 35 matching lines @@
   HandleDemuxMetadataUpdates();
 
   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(streams_.size(), stream_type.Pass())));
       Stream& stream = *streams_.back();
-      switch (stream.media_type_->scheme) {
-        case MediaTypeScheme::COMPRESSED_AUDIO:
-        case MediaTypeScheme::LPCM:
+      switch (stream.media_type_->medium) {
+        case MediaTypeMedium::AUDIO:
           stream.enabled_ = true;
           PrepareStream(streams_.back(), "mojo:audio_server",
                         callback_joiner->NewCallback());
           break;
         // TODO(dalesat): Enable other stream types.
         default:
           break;
       }
     }
 
@@ skipping 180 matching lines @@
   Update();
 }
 
 void MediaPlayerImpl::PrepareStream(const std::unique_ptr<Stream>& stream,
                                     const String& url,
                                     const std::function<void()>& callback) {
   DCHECK(factory_);
 
   demux_->GetProducer(stream->index_, GetProxy(&stream->encoded_producer_));
 
-  if (stream->media_type_->scheme == MediaTypeScheme::COMPRESSED_AUDIO) {
+  if (stream->media_type_->encoding != MediaType::kAudioEncodingLpcm) {
     std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
     // Compressed audio. 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(stream->media_type_.Clone(),
                             GetProxy(&stream->decoder_));
 
     MediaConsumerPtr decoder_consumer;
     stream->decoder_->GetConsumer(GetProxy(&decoder_consumer));
 
@@ skipping 10 matching lines @@
           stream->decoder_->GetProducer(GetProxy(&stream->decoded_producer_));
           CreateSink(stream, output_type, url, callback_joiner->NewCallback());
           callback_joiner->Complete();
         });
 
     callback_joiner->WhenJoined(callback);
   } else {
     // Uncompressed audio. Connect the demux stream directly to the sink. This
     // would work for compressed audio as well (the sink would decode), but we
     // want to test the decoder.
-    DCHECK(stream->media_type_->scheme == MediaTypeScheme::LPCM);
     stream->decoded_producer_ = stream->encoded_producer_.Pass();
     CreateSink(stream, stream->media_type_, url, callback);
   }
 }
 
 void MediaPlayerImpl::CreateSink(const std::unique_ptr<Stream>& stream,
                                  const MediaTypePtr& input_media_type,
                                  const String& url,
                                  const std::function<void()>& callback) {
   DCHECK(input_media_type);
@@ skipping 53 matching lines @@
       });
 }
 
 MediaPlayerImpl::Stream::Stream(size_t index, MediaTypePtr media_type)
     : index_(index), media_type_(media_type.Pass()) {}
 
 MediaPlayerImpl::Stream::~Stream() {}
 
 }  // namespace media
 }  // namespace mojo