Cast: Refactoring Cast API's

chrome/renderer/media/cast_rtp_stream.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_rtp_stream.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/renderer/media/cast_session.h"
@@ skipping 137 matching lines @@
     DCHECK(render_thread_task_runner_->BelongsToCurrentThread());
     DCHECK(frame_input_);
     // TODO(hclam): Pass in the accurate capture time to have good
     // audio/video sync.
     frame_input_->InsertRawVideoFrame(frame, base::TimeTicks::Now());
   }
 
   // Attach this sink to MediaStreamTrack. This method call must
   // be made on the render thread. Incoming data can then be
   // passed to media::cast::FrameInput on any thread.
-  void AddToTrack(const scoped_refptr<media::cast::FrameInput>& frame_input) {
+  void AddToTrack(
+      const scoped_refptr<media::cast::VideoFrameInput>& frame_input) {
     DCHECK(render_thread_task_runner_->BelongsToCurrentThread());
 
     frame_input_ = frame_input;
     if (!sink_added_) {
       AddToVideoTrack(this, track_);
       sink_added_ = true;
     }
   }
 
  private:
   blink::WebMediaStreamTrack track_;
-  scoped_refptr<media::cast::FrameInput> frame_input_;
+  scoped_refptr<media::cast::VideoFrameInput> frame_input_;
   bool sink_added_;
   CastRtpStream::ErrorCallback error_callback_;
   scoped_refptr<base::SingleThreadTaskRunner> render_thread_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(CastVideoSink);
 };
 
 // Receives audio data from a MediaStreamTrack. Data is submitted to
 // media::cast::FrameInput.
 //
@@ skipping 113 matching lines @@
     fifo_input_bus_ = media::AudioBus::Create(
         params.channels(), params.frames_per_buffer());
     resampler_.reset(new media::MultiChannelResampler(
         output_channels_,
         static_cast<double>(params.sample_rate()) / output_sample_rate_,
         params.frames_per_buffer(),
         base::Bind(&CastAudioSink::ProvideData, base::Unretained(this))));
   }
 
   // See CastVideoSink for details.
-  void AddToTrack(const scoped_refptr<media::cast::FrameInput>& frame_input) {
+  void AddToTrack(
+      const scoped_refptr<media::cast::AudioFrameInput>& frame_input) {
     DCHECK(render_thread_task_runner_->BelongsToCurrentThread());
     frame_input_ = frame_input;
     if (!sink_added_) {
       AddToAudioTrack(this, track_);
       sink_added_ = true;
     }
   }
 
   void ProvideData(int frame_delay, media::AudioBus* output_bus) {
     fifo_->Consume(output_bus, 0, output_bus->frames());
   }
 
  private:
   blink::WebMediaStreamTrack track_;
-  scoped_refptr<media::cast::FrameInput> frame_input_;
+  scoped_refptr<media::cast::AudioFrameInput> frame_input_;
   bool sink_added_;
   CastRtpStream::ErrorCallback error_callback_;
   base::WeakPtrFactory<CastAudioSink> weak_factory_;
   scoped_refptr<base::SingleThreadTaskRunner> render_thread_task_runner_;
 
   scoped_ptr<media::MultiChannelResampler> resampler_;
   scoped_ptr<media::AudioFifo> fifo_;
   scoped_ptr<media::AudioBus> fifo_input_bus_;
   int input_preroll_;
   const int output_channels_;
@@ skipping 11 matching lines @@
 
 CastRtpPayloadParams::CastRtpPayloadParams()
     : payload_type(0),
       ssrc(0),
       feedback_ssrc(0),
       clock_rate(0),
       max_bitrate(0),
       min_bitrate(0),
       channels(0),
       width(0),
-      height(0) {
-}
+      height(0) {}
 
-CastRtpPayloadParams::~CastRtpPayloadParams() {
-}
+CastRtpPayloadParams::~CastRtpPayloadParams() {}
 
-CastRtpParams::CastRtpParams() {
-}
+CastRtpParams::CastRtpParams() {}
 
-CastRtpParams::~CastRtpParams() {
-}
+CastRtpParams::~CastRtpParams() {}
 
 CastRtpStream::CastRtpStream(const blink::WebMediaStreamTrack& track,
                              const scoped_refptr<CastSession>& session)
-    : track_(track),
-      cast_session_(session),
-      weak_factory_(this) {}
+    : track_(track), cast_session_(session), weak_factory_(this) {}
 
-CastRtpStream::~CastRtpStream() {
-}
+CastRtpStream::~CastRtpStream() {}
 
 std::vector<CastRtpParams> CastRtpStream::GetSupportedParams() {
   if (IsAudio())
     return SupportedAudioParams();
   else
     return SupportedVideoParams();
 }
 
-CastRtpParams CastRtpStream::GetParams() {
-  return params_;
-}
+CastRtpParams CastRtpStream::GetParams() { return params_; }
 
 void CastRtpStream::Start(const CastRtpParams& params,
                           const base::Closure& start_callback,
                           const base::Closure& stop_callback,
                           const ErrorCallback& error_callback) {
   stop_callback_ = stop_callback;
   error_callback_ = error_callback;
 
   if (IsAudio()) {
     AudioSenderConfig config;
     if (!ToAudioSenderConfig(params, &config)) {
       DidEncounterError("Invalid parameters for audio.");
       return;
     }
 
     // In case of error we have to go through DidEncounterError() to stop
     // the streaming after reporting the error.
     audio_sink_.reset(new CastAudioSink(
         track_,
         media::BindToCurrentLoop(base::Bind(&CastRtpStream::DidEncounterError,
                                             weak_factory_.GetWeakPtr())),
         params.payload.channels,
         params.payload.clock_rate));
     cast_session_->StartAudio(
         config,
-        base::Bind(&CastAudioSink::AddToTrack,
-                   audio_sink_->AsWeakPtr()));
+        base::Bind(&CastAudioSink::AddToTrack, audio_sink_->AsWeakPtr()));
     start_callback.Run();
   } else {
     VideoSenderConfig config;
     if (!ToVideoSenderConfig(params, &config)) {
       DidEncounterError("Invalid parameters for video.");
       return;
     }
     // See the code for audio above for explanation of callbacks.
     video_sink_.reset(new CastVideoSink(
         track_,
         media::BindToCurrentLoop(base::Bind(&CastRtpStream::DidEncounterError,
                                             weak_factory_.GetWeakPtr()))));
     cast_session_->StartVideo(
         config,
-        base::Bind(&CastVideoSink::AddToTrack,
-                   video_sink_->AsWeakPtr()));
+        base::Bind(&CastVideoSink::AddToTrack, video_sink_->AsWeakPtr()));
     start_callback.Run();
   }
 }
 
 void CastRtpStream::Stop() {
   audio_sink_.reset();
   video_sink_.reset();
   stop_callback_.Run();
 }
 
@@ skipping 12 matching lines @@
 }
 
 bool CastRtpStream::IsAudio() const {
   return track_.source().type() == blink::WebMediaStreamSource::TypeAudio;
 }
 
 void CastRtpStream::DidEncounterError(const std::string& message) {
   error_callback_.Run(message);
   Stop();
 }