Motown: Use new TimelineTransform and related definitions

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_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_runner.h"
@@ skipping 110 matching lines @@
     MOJO_DCHECK(wav_info_.frame_size);
     MOJO_DCHECK(frames <
                 std::numeric_limits<uint32_t>::max() / wav_info_.frame_size);
 
     return frames * wav_info_.frame_size;
   }
 
   AudioServerPtr               audio_server_;
   AudioTrackPtr                audio_track_;
   AudioPipePtr                 audio_pipe_;
-  RateControlPtr               rate_control_;
+  TimelineConsumerPtr          timeline_consumer_;
   AudioPacket                  audio_packet_;
   PacketCbk                    playout_complete_cbk_;
   NetworkServicePtr            network_service_;
   URLLoaderPtr                 url_loader_;
   ScopedDataPipeConsumerHandle payload_;
   uint32_t                     payload_len_;
   RIFFChunkHeader              riff_hdr_;
   WAVHeader                    wav_info_;
   RIFFChunkHeader              data_hdr_;
   bool                         sent_first_packet_ = false;
@@ skipping 47 matching lines @@
 void PlayWAVApp::Quit() {
   if (audio_packet_.packet()) {
     MOJO_DCHECK(audio_pipe_);
     audio_pipe_->CancelMediaPacket(&audio_packet_);
   }
 
   payload_.reset();
   url_loader_.reset();
   network_service_.reset();
   audio_pipe_.reset();
-  rate_control_.reset();
+  timeline_consumer_.reset();
   audio_track_.reset();
   audio_server_.reset();
 }
 
 bool PlayWAVApp::BlockingRead(void* buf, uint32_t op_len) {
   MojoResult res;
   uint32_t amt;
 
   while (true) {
     amt = op_len;
@@ skipping 73 matching lines @@
   cfg->media_type = MediaType::New();
   cfg->media_type->medium = MediaTypeMedium::AUDIO;
   cfg->media_type->details = MediaTypeDetails::New();
   cfg->media_type->details->set_audio(pcm_cfg.Pass());
   cfg->media_type->encoding = MediaType::kAudioEncodingLpcm;
 
   // Configure the track based on the WAV header information.
   MediaConsumerPtr media_pipe;
   audio_track_->Configure(cfg.Pass(), GetProxy(&media_pipe));
 
-  // Grab the rate control interface for our audio renderer.
-  audio_track_->GetRateControl(GetProxy(&rate_control_));
-  rate_control_.set_connection_error_handler([this]() {
-    OnConnectionError("rate_control");
-  });
+  // Grab the timeline consumer interface for our audio renderer.
+  MediaTimelineControlSitePtr timeline_control_site;
+  audio_track_->GetTimelineControlSite(GetProxy(&timeline_control_site));
+  timeline_control_site->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.
   audio_pipe_.reset(new CircularBufferMediaPipeAdapter(media_pipe.Pass()));
   audio_pipe_->Init(USecToBytes(BUF_DEPTH_USEC));
   audio_pipe_->SetWatermarks(USecToBytes(BUF_HI_WATER_USEC),
                              USecToBytes(BUF_LO_WATER_USEC));
   audio_pipe_->SetSignalCallback(
   [this](MediaResult res) -> void {
     OnNeedsData(res);
@@ skipping 186 matching lines @@
   }
 
   if (res != MediaResult::OK) {
     MOJO_LOG(ERROR) << "Failed to send media packet!  "
                     << "(res = " << res << ")";
     PostShutdown();
     return;
   }
 
   if (!clock_started_ && (audio_pipe_->AboveHiWater() || !payload_len_)) {
-    LocalTime sched = LocalClock::now() + local_time::from_msec(50);
-    rate_control_->SetRateAtTargetTime(1, 1, sched.time_since_epoch().count());
+    timeline_consumer_->SetTimelineTransform(
+        kUnspecifiedTime, 1, 1, kUnspecifiedTime, kUnspecifiedTime,
+        [](bool completed) {});
     clock_started_ = true;
   }
 }
 
 void PlayWAVApp::OnPlayoutComplete(MediaConsumer::SendResult res) {
   MOJO_DCHECK(!audio_pipe_->GetPending());
   audio_pipe_ = nullptr;
   PostShutdown();
 }
 
@@ skipping 37 matching lines @@
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle app_request) {
   mojo::ApplicationRunner runner(
       std::unique_ptr<mojo::media::audio::examples::PlayWAVApp>(
           new mojo::media::audio::examples::PlayWAVApp()));
   return runner.Run(app_request);
 }