Motown: Change media type (stream type) representation

services/media/factory_service/media_demux_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_demux_impl.h"
 #include "services/media/framework/callback_joiner.h"
 #include "services/media/framework/parts/reader_cache.h"
@@ skipping 53 matching lines @@
                            base::Bind(&MediaDemuxImpl::OnDemuxInitialized,
                                       base::Unretained(this), result));
   });
 }
 
 MediaDemuxImpl::~MediaDemuxImpl() {}
 
 void MediaDemuxImpl::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();

[kulakowski, 2016/04/19 19:18:22]

I'm curious why the move away from auto/auto&/auto* etc.

[dalesat, 2016/04/19 19:47:03]

I like auto a lot, but previous reviewers have not. These got by somehow. The
guidance I've gotten in past reviews is that auto should only be used when a
type doesn't have a name or when the name is super-obscure. Personally, I prefer
to use auto pretty much whenever the compiler will let me.

[kulakowski, 2016/04/20 17:42:37]

Makes sense.

I would prefer to use it where it is clear and robust to nonlocal changes.

+  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(), &graph_)));
   }
 
   graph_.Prepare();
 
   metadata_publisher_.SendUpdates();
 
   init_complete_.Occur();
 }
 
 void MediaDemuxImpl::Describe(const DescribeCallback& callback) {
   init_complete_.When([this, callback]() {
-    auto result = Array<MediaTypePtr>::New(streams_.size());
+    Array<MediaTypePtr> result = Array<MediaTypePtr>::New(streams_.size());
     for (size_t i = 0; i < streams_.size(); i++) {
       MediaSourceStreamDescriptorPtr descriptor =
           MediaSourceStreamDescriptor::New();
       result[i] = streams_[i]->media_type();
     }
+
     callback.Run(result.Pass());
   });
 }
 
 void MediaDemuxImpl::GetProducer(uint32_t stream_index,
                                  InterfaceRequest<MediaProducer> producer) {
   DCHECK(init_complete_.occurred());
 
   if (stream_index >= streams_.size()) {
     return;
   }
 
   streams_[stream_index]->GetProducer(producer.Pass());
 }
 
 void MediaDemuxImpl::GetMetadata(uint64_t version_last_seen,
                                  const GetMetadataCallback& callback) {
   metadata_publisher_.Get(version_last_seen, callback);
 }
 
 void MediaDemuxImpl::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 MediaDemuxImpl::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 MediaDemuxImpl::Seek(int64_t position, const SeekCallback& callback) {
   DCHECK(init_complete_.occurred());
 
   demux_->Seek(position, [this, callback]() {
@@ skipping 36 matching lines @@
 }
 
 void MediaDemuxImpl::Stream::FlushConnection(
     const MojoProducer::FlushConnectionCallback callback) {
   DCHECK(producer_);
   producer_->FlushConnection(callback);
 }
 
 }  // namespace media
 }  // namespace mojo