Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

services/media/factory_service/media_sink_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_sink_impl.h"
 #include "services/media/framework/util/conversion_pipeline_builder.h"
 #include "services/media/framework_mojo/mojo_type_conversions.h"
 
 namespace mojo {
 namespace media {
 
 // static
 std::shared_ptr<MediaSinkImpl> MediaSinkImpl::Create(
     InterfaceHandle<MediaRenderer> renderer,
     MediaTypePtr media_type,
     InterfaceRequest<MediaSink> request,
     MediaFactoryService* owner) {
   return std::shared_ptr<MediaSinkImpl>(new MediaSinkImpl(
       renderer.Pass(), media_type.Pass(), request.Pass(), owner));
 }
 
 MediaSinkImpl::MediaSinkImpl(InterfaceHandle<MediaRenderer> renderer,
                              MediaTypePtr media_type,
                              InterfaceRequest<MediaSink> request,
                              MediaFactoryService* owner)
     : MediaFactoryService::Product<MediaSink>(this, request.Pass(), owner),
-      consumer_(MojoConsumer::Create()),
-      producer_(MojoProducer::Create()),
+      consumer_(MojoPacketConsumer::Create()),
+      producer_(MojoPacketProducer::Create()),
       renderer_(MediaRendererPtr::Create(renderer.Pass())) {
   DCHECK(renderer_);
   DCHECK(media_type);
 
   PartRef consumer_ref = graph_.Add(consumer_);
   PartRef producer_ref = graph_.Add(producer_);
 
   consumer_->SetPrimeRequestedCallback(
-      [this](const MediaConsumer::PrimeCallback& callback) {
+      [this](const MediaPacketConsumer::PrimeCallback& callback) {
         ready_.When([this, callback]() {
           DCHECK(producer_);
           producer_->PrimeConnection(callback);
         });
       });
   consumer_->SetFlushRequestedCallback(
-      [this, consumer_ref](const MediaConsumer::FlushCallback& callback) {
+      [this, consumer_ref](const MediaPacketConsumer::FlushCallback& callback) {
         ready_.When([this, consumer_ref, callback]() {
           DCHECK(producer_);
           graph_.FlushOutput(consumer_ref.output());
           producer_->FlushConnection(callback);
         });
       });
 
   // TODO(dalesat): Once we have c++14, get rid of this shared pointer hack.
   input_stream_type_ = media_type.To<std::unique_ptr<StreamType>>();
 
@@ skipping 13 matching lines @@
     if (!result) {
       // Failed to build conversion pipeline.
       LOG(WARNING) << "failed to build conversion pipeline";
       // TODO(dalesat): Add problem reporting.
       return;
     }
 
     graph_.ConnectOutputToPart(out, producer_ref);
 
     renderer_->SetMediaType(MediaType::From(std::move(producer_stream_type)));
-    MediaConsumerPtr consumer;
-    renderer_->GetConsumer(GetProxy(&consumer));
+    MediaPacketConsumerPtr consumer;
+    renderer_->GetPacketConsumer(GetProxy(&consumer));
     producer_->Connect(consumer.Pass(), [this]() {
       graph_.Prepare();
       ready_.Occur();
     });
   });
 }
 
 MediaSinkImpl::~MediaSinkImpl() {}
 
-void MediaSinkImpl::GetConsumer(InterfaceRequest<MediaConsumer> consumer) {
+void MediaSinkImpl::GetPacketConsumer(
+    InterfaceRequest<MediaPacketConsumer> consumer) {
   consumer_->AddBinding(consumer.Pass());
 }
 
 void MediaSinkImpl::GetTimelineControlPoint(
     InterfaceRequest<MediaTimelineControlPoint> req) {
   DCHECK(renderer_);
   renderer_->GetTimelineControlPoint(req.Pass());
 }
 
 }  // namespace media
 }  // namespace mojo