Motown: Rename MediaProducer/Consumer to MediaPacketProducer/Consumer

examples/audio_play_test/play_wav.cc

 // Copyright 2015 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 <memory>
 
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_impl_base.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/run_application.h"
@@ skipping 42 matching lines @@
  public:
   ~PlayWAVApp() override { OnQuit(); }
 
   // ApplicationImplBase overrides:
   void OnInitialize() override;
   void OnQuit() override;
 
  private:
   using AudioPipePtr = std::unique_ptr<CircularBufferMediaPipeAdapter>;
   using AudioPacket  = CircularBufferMediaPipeAdapter::MappedPacket;
-  using PacketCbk    = MediaConsumer::SendPacketCallback;
+  using PacketCbk    = MediaPacketConsumer::SendPacketCallback;
 
   // TODO(johngro): endianness!
   struct PACKED RIFFChunkHeader {
     uint32_t  four_cc;
     uint32_t  length;
   };
 
   struct PACKED WAVHeader {
     uint32_t  wave_four_cc;
     uint32_t  fmt_four_cc;
@@ skipping 22 matching lines @@
   static const std::set<uint16_t>    VALID_BITS_PER_SAMPLES;
 
   bool BlockingRead(void* buf, uint32_t len);
   void ProcessHTTPResponse(URLResponsePtr resp);
 
   bool ReadAndValidateRIFFHeader();
   bool ReadAndValidateWAVHeader();
   bool ReadAndValidateDATAHeader();
 
   void OnNeedsData(MediaResult res);
-  void OnPlayoutComplete(MediaConsumer::SendResult res);
+  void OnPlayoutComplete(MediaPacketConsumer::SendResult res);
   void OnConnectionError(const std::string& connection_name);
   void PostShutdown();
   void Shutdown();
 
   uint32_t USecToFrames(uint32_t usec) {
     uint64_t ret = (static_cast<uint64_t>(usec) * wav_info_.frame_rate)
                  / 1000000;
     MOJO_DCHECK(ret < std::numeric_limits<uint32_t>::max());
     return ret;
   }
@@ skipping 51 matching lines @@
                    GetProxy(&network_service_));
   audio_server_.set_connection_error_handler([this]() {
     OnConnectionError("network_service");
   });
 
   network_service_->CreateURLLoader(GetProxy(&url_loader_));
   url_loader_.set_connection_error_handler([this]() {
     OnConnectionError("url_loader");
   });
 
-  playout_complete_cbk_ = PacketCbk([this](MediaConsumer::SendResult res) {
-                                      this->OnPlayoutComplete(res);
-                                    });
+  playout_complete_cbk_ =
+      PacketCbk([this](MediaPacketConsumer::SendResult res) {
+        this->OnPlayoutComplete(res);
+      });
 
   URLRequestPtr req(URLRequest::New());
   req->url    = TEST_FILE;
   req->method = "GET";
 
   auto cbk = [this](URLResponsePtr resp) { ProcessHTTPResponse(resp.Pass()); };
   url_loader_->Start(req.Pass(), URLLoader::StartCallback(cbk));
 }
 
 void PlayWAVApp::OnQuit() {
@@ skipping 84 matching lines @@
   pcm_cfg->frames_per_second = wav_info_.frame_rate;
 
   MediaTypePtr media_type = MediaType::New();
   media_type->medium = MediaTypeMedium::AUDIO;
   media_type->details = MediaTypeDetails::New();
   media_type->details->set_audio(pcm_cfg.Pass());
   media_type->encoding = MediaType::kAudioEncodingLpcm;
 
   // Configure the track based on the WAV header information.
   media_renderer_->SetMediaType(media_type.Pass());
-  MediaConsumerPtr media_pipe;
-  media_renderer_->GetConsumer(GetProxy(&media_pipe));
+  MediaPacketConsumerPtr media_pipe;
+  media_renderer_->GetPacketConsumer(GetProxy(&media_pipe));
 
   // Grab the timeline consumer interface for our audio renderer.
   MediaTimelineControlPointPtr timeline_control_point;
   media_renderer_->GetTimelineControlPoint(GetProxy(&timeline_control_point));
   timeline_control_point->GetTimelineConsumer(GetProxy(&timeline_consumer_));
   timeline_consumer_.set_connection_error_handler(
       [this]() { OnConnectionError("timeline_consumer"); });
 
   // Set up our media pipe helper, configure its callback and water marks to
   // kick off the playback process.
@@ skipping 204 matching lines @@
     timeline_transform->reference_time = kUnspecifiedTime;
     timeline_transform->subject_time = kUnspecifiedTime;
     timeline_transform->reference_delta = 1;
     timeline_transform->subject_delta = 1;
     timeline_consumer_->SetTimelineTransform(timeline_transform.Pass(),
                                              [](bool completed) {});
     clock_started_ = true;
   }
 }
 
-void PlayWAVApp::OnPlayoutComplete(MediaConsumer::SendResult res) {
+void PlayWAVApp::OnPlayoutComplete(MediaPacketConsumer::SendResult res) {
   MOJO_DCHECK(!audio_pipe_->GetPending());
   audio_pipe_ = nullptr;
   PostShutdown();
 }
 
 void PlayWAVApp::OnConnectionError(const std::string& connection_name) {
   if (!shutting_down_) {
     MOJO_LOG(ERROR) << connection_name << " connection closed unexpectedly!";
     PostShutdown();
   }
@@ skipping 30 matching lines @@
 
 }  // namespace examples
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle app_request) {
   mojo::media::audio::examples::PlayWAVApp play_wav_app;
   return mojo::RunApplication(app_request, &play_wav_app);
 }