Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

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"
@@ skipping 278 matching lines @@
   target_position_ = position;
   Update();
 }
 
 void MediaPlayerImpl::PrepareStream(Stream* stream,
                                     size_t index,
                                     const MediaTypePtr& input_media_type,
                                     const std::function<void()>& callback) {
   DCHECK(factory_);
 
-  demux_->GetProducer(index, GetProxy(&stream->encoded_producer_));
+  demux_->GetPacketProducer(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));
+    MediaPacketConsumerPtr decoder_consumer;
+    stream->decoder_->GetPacketConsumer(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, callback_joiner](MediaTypePtr output_type) {
-          stream->decoder_->GetProducer(GetProxy(&stream->decoded_producer_));
-          CreateSink(stream, output_type, callback_joiner->NewCallback());
-          callback_joiner->Complete();
-        });
+    stream->decoder_->GetOutputType([this, stream, callback_joiner](
+        MediaTypePtr output_type) {
+      stream->decoder_->GetPacketProducer(GetProxy(&stream->decoded_producer_));
+      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, callback);
   }
 }
 
 void MediaPlayerImpl::CreateSink(Stream* stream,
                                  const MediaTypePtr& input_media_type,
                                  const std::function<void()>& callback) {
   DCHECK(input_media_type);
   DCHECK(stream->decoded_producer_);
   DCHECK(factory_);
 
   factory_->CreateSink(stream->renderer_.Pass(), input_media_type.Clone(),
                        GetProxy(&stream->sink_));
 
   MediaTimelineControlPointPtr timeline_control_point;
   stream->sink_->GetTimelineControlPoint(GetProxy(&timeline_control_point));
 
   timeline_controller_->AddControlPoint(timeline_control_point.Pass());
 
-  MediaConsumerPtr consumer;
-  stream->sink_->GetConsumer(GetProxy(&consumer));
+  MediaPacketConsumerPtr consumer;
+  stream->sink_->GetPacketConsumer(GetProxy(&consumer));
 
   stream->decoded_producer_->Connect(consumer.Pass(),
                                      [this, callback, stream]() {
                                        stream->decoded_producer_.reset();
                                        callback();
                                      });
 }
 
 void MediaPlayerImpl::HandleDemuxMetadataUpdates(uint64_t version,
                                                  MediaMetadataPtr metadata) {
@@ skipping 24 matching lines @@
         HandleTimelineControlPointStatusUpdates(version, status.Pass());
       });
 }
 
 MediaPlayerImpl::Stream::Stream() {}
 
 MediaPlayerImpl::Stream::~Stream() {}
 
 }  // namespace media
 }  // namespace mojo