Motown: Change media type (stream type) representation

services/media/factory_service/media_source_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/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "services/media/factory_service/media_source_impl.h"
 #include "services/media/framework/callback_joiner.h"
 #include "services/media/framework/conversion_pipeline_builder.h"
@@ skipping 58 matching lines @@
                            base::Bind(&MediaSourceImpl::OnDemuxInitialized,
                                       base::Unretained(this), result));
   });
 }
 
 MediaSourceImpl::~MediaSourceImpl() {}
 
 void MediaSourceImpl::OnDemuxInitialized(Result result) {
   demux_part_ = graph_.Add(demux_);
 
-  auto demux_streams = demux_->streams();
-  for (auto demux_stream : demux_streams) {
+  const std::vector<Demux::DemuxStream*>& demux_streams = demux_->streams();
+  for (Demux::DemuxStream* demux_stream : demux_streams) {
     streams_.push_back(std::unique_ptr<Stream>(new Stream(
         demux_part_.output(demux_stream->index()), demux_stream->stream_type(),
         Convert(allowed_media_types_), &graph_)));
   }
 
   allowed_media_types_.reset();
 
   init_complete_.Occur();
 }
 
 void MediaSourceImpl::GetStreams(const GetStreamsCallback& callback) {
   init_complete_.When([this, callback]() {
-    auto result = Array<MediaSourceStreamDescriptorPtr>::New(streams_.size());
+    Array<MediaSourceStreamDescriptorPtr> result =
+        Array<MediaSourceStreamDescriptorPtr>::New(streams_.size());
     for (size_t i = 0; i < streams_.size(); i++) {
       MediaSourceStreamDescriptorPtr descriptor =
           MediaSourceStreamDescriptor::New();
       descriptor->index = i;
       descriptor->media_type = streams_[i]->media_type();
       descriptor->original_media_type = streams_[i]->original_media_type();
       result[i] = descriptor.Pass();
     }
     callback.Run(result.Pass());
   });
@@ skipping 23 matching lines @@
 }
 
 void MediaSourceImpl::GetStatus(uint64_t version_last_seen,
                                 const GetStatusCallback& callback) {
   status_publisher_.Get(version_last_seen, callback);
 }
 
 void MediaSourceImpl::Prepare(const PrepareCallback& callback) {
   DCHECK(init_complete_.occurred());
 
-  for (auto& stream : streams_) {
+  for (std::unique_ptr<Stream>& stream : streams_) {
     stream->EnsureSink();
   }
   graph_.Prepare();
   state_ = MediaState::PAUSED;
   callback.Run();
   status_publisher_.SendUpdates();
 }
 
 void MediaSourceImpl::Prime(const PrimeCallback& callback) {
   DCHECK(init_complete_.occurred());
 
   std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
-  for (auto& stream : streams_) {
+  for (std::unique_ptr<Stream>& stream : streams_) {
     stream->PrimeConnection(callback_joiner->NewCallback());
   }
 
   callback_joiner->WhenJoined(callback);
 }
 
 void MediaSourceImpl::Flush(const FlushCallback& callback) {
   DCHECK(init_complete_.occurred());
 
   graph_.FlushAllOutputs(demux_part_);
 
   std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
 
-  for (auto& stream : streams_) {
+  for (std::unique_ptr<Stream>& stream : streams_) {
     stream->FlushConnection(callback_joiner->NewCallback());
   }
 
   callback_joiner->WhenJoined(callback);
 }
 
 void MediaSourceImpl::Seek(int64_t position, const SeekCallback& callback) {
   DCHECK(init_complete_.occurred());
 
   demux_->Seek(position, [this, callback]() {
@@ skipping 18 matching lines @@
 
   output_ = output;
 
   if (allowed_stream_types == nullptr) {
     // No conversion requested.
     stream_type_ = SafeClone(original_stream_type_);
   } else if (!BuildConversionPipeline(*original_stream_type_,
                                       *allowed_stream_types, graph, &output_,
                                       &stream_type_)) {
     // Can't convert to any allowed type.
-    stream_type_ = StreamType::Create(StreamType::Scheme::kNone);
+    // TODO(dalesat): Indicate this in some way other than blowing up.
+    LOG(ERROR) << "can't convert to any allowed type";
+    abort();
   }
 }
 
 MediaSourceImpl::Stream::~Stream() {}
 
 MediaTypePtr MediaSourceImpl::Stream::media_type() const {
   return Convert(stream_type_);
 }
 
 MediaTypePtr MediaSourceImpl::Stream::original_media_type() const {
@@ skipping 50 matching lines @@
     const MojoProducer::FlushConnectionCallback callback) {
   if (producer_ != nullptr) {
     producer_->FlushConnection(callback);
   } else {
     callback.Run();
   }
 }
 
 }  // namespace media
 }  // namespace mojo