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 126 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 51 matching lines @@
     DCHECK(frame_input_);
     frame_input_->InsertAudio(audio_bus_ptr, recorded_time, done_callback);
   }
 
   // Called on real-time audio thread.
   virtual void OnSetFormat(const media::AudioParameters& params) OVERRIDE {
     NOTIMPLEMENTED();
   }
 
   // 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;
     }
   }
 
  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_;
 
   DISALLOW_COPY_AND_ASSIGN(CastAudioSink);
 };
 
 CastRtpParams::CastRtpParams(const CastRtpPayloadParams& payload_params)
     : payload(payload_params) {}
 
 CastCodecSpecificParams::CastCodecSpecificParams() {}
 
 CastCodecSpecificParams::~CastCodecSpecificParams() {}
 
 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()))));
     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();
 }
 
 void CastRtpStream::ToggleLogging(bool enable) {
   cast_session_->ToggleLogging(IsAudio(), enable);
 }
 
 void CastRtpStream::GetRawEvents(
     const base::Callback<void(scoped_ptr<std::string>)>& callback) {
   cast_session_->GetEventLogsAndReset(IsAudio(), callback);
 }
 
 bool CastRtpStream::IsAudio() const {
   return track_.source().type() == blink::WebMediaStreamSource::TypeAudio;
 }
 
 void CastRtpStream::DidEncounterError(const std::string& message) {
   error_callback_.Run(message);
   Stop();
 }