Cast:Adding cast_transport_config and cleaning up

BUG=327482

Review URL: https://codereview.chromium.org/109413004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@243647 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 38 insertions, 33 deletions

diff --git a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
index 12c54428..ade419b 100644
--- a/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
+++ b/media/cast/video_receiver/codecs/vp8/vp8_decoder.cc
@@ -54,7 +54,7 @@ void Vp8Decoder::InitDecoder() {
   }
 }
 
-bool Vp8Decoder::Decode(const EncodedVideoFrame* encoded_frame,
+bool Vp8Decoder::Decode(const transport::EncodedVideoFrame* encoded_frame,
                         const base::TimeTicks render_time,
                         const VideoFrameDecodedCallback& frame_decoded_cb) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
diff --git a/media/cast/video_receiver/codecs/vp8/vp8_decoder.h b/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
index 6a93c41..361a71e 100644
--- a/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
+++ b/media/cast/video_receiver/codecs/vp8/vp8_decoder.h
@@ -29,7 +29,7 @@ class Vp8Decoder : public base::NonThreadSafe {
   // Will return false in case of error, and then it's up to the caller to
   // release the memory.
   // Ownership of the encoded_frame does not pass to the Vp8Decoder.
-  bool Decode(const EncodedVideoFrame* encoded_frame,
+  bool Decode(const transport::EncodedVideoFrame* encoded_frame,
               const base::TimeTicks render_time,
               const VideoFrameDecodedCallback& frame_decoded_cb);
 
diff --git a/media/cast/video_receiver/video_decoder.cc b/media/cast/video_receiver/video_decoder.cc
index aaa6811..d7ce09f 100644
--- a/media/cast/video_receiver/video_decoder.cc
+++ b/media/cast/video_receiver/video_decoder.cc
@@ -17,10 +17,10 @@ VideoDecoder::VideoDecoder(const VideoReceiverConfig& video_config,
     : codec_(video_config.codec),
       vp8_decoder_() {
   switch (video_config.codec) {
-    case kVp8:
+    case transport::kVp8:
       vp8_decoder_.reset(new Vp8Decoder(cast_environment));
       break;
-    case kH264:
+    case transport::kH264:
       NOTIMPLEMENTED();
       break;
   }
@@ -28,10 +28,11 @@ VideoDecoder::VideoDecoder(const VideoReceiverConfig& video_config,
 
 VideoDecoder::~VideoDecoder() {}
 
-bool VideoDecoder::DecodeVideoFrame(const EncodedVideoFrame* encoded_frame,
-                                    const base::TimeTicks render_time,
-                                    const VideoFrameDecodedCallback&
-                                    frame_decoded_cb) {
+bool VideoDecoder::DecodeVideoFrame(
+    const transport::EncodedVideoFrame* encoded_frame,
+    const base::TimeTicks render_time,
+    const VideoFrameDecodedCallback&
+    frame_decoded_cb) {
   DCHECK(encoded_frame->codec == codec_) << "Invalid codec";
   DCHECK_GT(encoded_frame->data.size(), GG_UINT64_C(0)) << "Empty video frame";
   return vp8_decoder_->Decode(encoded_frame, render_time, frame_decoded_cb);
diff --git a/media/cast/video_receiver/video_decoder.h b/media/cast/video_receiver/video_decoder.h
index 97a8a62..f1146ae 100644
--- a/media/cast/video_receiver/video_decoder.h
+++ b/media/cast/video_receiver/video_decoder.h
@@ -26,12 +26,12 @@ class VideoDecoder : public base::NonThreadSafe {
 
   // Decode a video frame. Decoded (raw) frame will be returned via the
   // provided callback
-  bool DecodeVideoFrame(const EncodedVideoFrame* encoded_frame,
+  bool DecodeVideoFrame(const transport::EncodedVideoFrame* encoded_frame,
                         const base::TimeTicks render_time,
                         const VideoFrameDecodedCallback& frame_decoded_cb);
 
  private:
-  VideoCodec codec_;
+  transport::VideoCodec codec_;
   scoped_ptr<Vp8Decoder> vp8_decoder_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoder);
diff --git a/media/cast/video_receiver/video_decoder_unittest.cc b/media/cast/video_receiver/video_decoder_unittest.cc
index 0987dd4..1d9cf77 100644
--- a/media/cast/video_receiver/video_decoder_unittest.cc
+++ b/media/cast/video_receiver/video_decoder_unittest.cc
@@ -43,10 +43,10 @@ class VideoDecoderTest : public ::testing::Test {
     : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
       cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
           task_runner_, task_runner_, task_runner_, task_runner_,
-          GetDefaultCastLoggingConfig())),
+          task_runner_, GetDefaultCastLoggingConfig())),
       test_callback_(new DecodeTestFrameCallback()) {
     // Configure to vp8.
-    config_.codec = kVp8;
+    config_.codec = transport::kVp8;
     config_.use_external_decoder = false;
     decoder_.reset(new VideoDecoder(config_, cast_environment_));
     testing_clock_.Advance(
@@ -65,9 +65,9 @@ class VideoDecoderTest : public ::testing::Test {
 
 // TODO(pwestin): EXPECT_DEATH tests can not pass valgrind.
 TEST_F(VideoDecoderTest, DISABLED_SizeZero) {
-  EncodedVideoFrame encoded_frame;
+  transport::EncodedVideoFrame encoded_frame;
   base::TimeTicks render_time;
-  encoded_frame.codec = kVp8;
+  encoded_frame.codec = transport::kVp8;
   EXPECT_DEATH(
       decoder_->DecodeVideoFrame(
           &encoded_frame, render_time,
diff --git a/media/cast/video_receiver/video_receiver.cc b/media/cast/video_receiver/video_receiver.cc
index d304d8b..8976468 100644
--- a/media/cast/video_receiver/video_receiver.cc
+++ b/media/cast/video_receiver/video_receiver.cc
@@ -159,7 +159,7 @@ void VideoReceiver::GetRawVideoFrame(
 // Called when we have a frame to decode.
 void VideoReceiver::DecodeVideoFrame(
     const VideoFrameDecodedCallback& callback,
-    scoped_ptr<EncodedVideoFrame> encoded_frame,
+    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
     const base::TimeTicks& render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Hand the ownership of the encoded frame to the decode thread.
@@ -170,7 +170,7 @@ void VideoReceiver::DecodeVideoFrame(
 
 // Utility function to run the decoder on a designated decoding thread.
 void VideoReceiver::DecodeVideoFrameThread(
-    scoped_ptr<EncodedVideoFrame> encoded_frame,
+    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
     const base::TimeTicks render_time,
     const VideoFrameDecodedCallback& frame_decoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
@@ -186,7 +186,7 @@ void VideoReceiver::DecodeVideoFrameThread(
 }
 
 bool VideoReceiver::DecryptVideoFrame(
-    scoped_ptr<EncodedVideoFrame>* video_frame) {
+    scoped_ptr<transport::EncodedVideoFrame>* video_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(decryptor_) << "Invalid state";
 
@@ -210,7 +210,8 @@ bool VideoReceiver::DecryptVideoFrame(
 void VideoReceiver::GetEncodedVideoFrame(
     const VideoFrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
+  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
+      new transport::EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
@@ -245,7 +246,7 @@ void VideoReceiver::GetEncodedVideoFrame(
 // If the frame is too old to be rendered we set the don't show flag in the
 // video bitstream where possible.
 bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
-    bool next_frame, scoped_ptr<EncodedVideoFrame>* encoded_frame,
+    bool next_frame, scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
     base::TimeTicks* render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
@@ -278,7 +279,8 @@ bool VideoReceiver::PullEncodedVideoFrame(uint32 rtp_timestamp,
 
   base::TimeDelta dont_show_timeout_delta =
       base::TimeDelta::FromMilliseconds(-kDontShowTimeoutMs);
-  if (codec_ == kVp8 && time_until_render < dont_show_timeout_delta) {
+  if (codec_ == transport::kVp8 &&
+      time_until_render < dont_show_timeout_delta) {
     (*encoded_frame)->data[0] &= 0xef;
     VLOG(1) << "Don't show frame "
             << static_cast<int>((*encoded_frame)->frame_id)
@@ -300,7 +302,8 @@ void VideoReceiver::PlayoutTimeout() {
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
+  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
+      new transport::EncodedVideoFrame());
 
   if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
diff --git a/media/cast/video_receiver/video_receiver.h b/media/cast/video_receiver/video_receiver.h
index 404f9f6..bb7b3a7 100644
--- a/media/cast/video_receiver/video_receiver.h
+++ b/media/cast/video_receiver/video_receiver.h
@@ -61,7 +61,7 @@ class VideoReceiver : public base::NonThreadSafe,
                                const RtpCastHeader& rtp_header);
 
   void DecodeVideoFrameThread(
-      scoped_ptr<EncodedVideoFrame> encoded_frame,
+      scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
       const base::TimeTicks render_time,
       const VideoFrameDecodedCallback& frame_decoded_callback);
 
@@ -72,15 +72,16 @@ class VideoReceiver : public base::NonThreadSafe,
   void CastFeedback(const RtcpCastMessage& cast_message);
 
   void DecodeVideoFrame(const VideoFrameDecodedCallback& callback,
-                        scoped_ptr<EncodedVideoFrame> encoded_frame,
+                        scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
                         const base::TimeTicks& render_time);
 
-  bool DecryptVideoFrame(scoped_ptr<EncodedVideoFrame>* video_frame);
+  bool DecryptVideoFrame(scoped_ptr<transport::EncodedVideoFrame>* video_frame);
 
-  bool PullEncodedVideoFrame(uint32 rtp_timestamp,
-                             bool next_frame,
-                             scoped_ptr<EncodedVideoFrame>* encoded_frame,
-                             base::TimeTicks* render_time);
+  bool PullEncodedVideoFrame(
+      uint32 rtp_timestamp,
+      bool next_frame,
+      scoped_ptr<transport::EncodedVideoFrame>* encoded_frame,
+      base::TimeTicks* render_time);
 
   void PlayoutTimeout();
 
@@ -104,7 +105,7 @@ class VideoReceiver : public base::NonThreadSafe,
   scoped_ptr<VideoDecoder> video_decoder_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<Framer> framer_;
-  const VideoCodec codec_;
+  const transport::VideoCodec codec_;
   base::TimeDelta target_delay_delta_;
   base::TimeDelta frame_delay_;
   scoped_ptr<LocalRtpVideoData> incoming_payload_callback_;
diff --git a/media/cast/video_receiver/video_receiver_unittest.cc b/media/cast/video_receiver/video_receiver_unittest.cc
index e13f0f5..e382371 100644
--- a/media/cast/video_receiver/video_receiver_unittest.cc
+++ b/media/cast/video_receiver/video_receiver_unittest.cc
@@ -35,10 +35,10 @@ class TestVideoReceiverCallback :
     ++num_called_;
   }
 
-  void FrameToDecode(scoped_ptr<EncodedVideoFrame> video_frame,
+  void FrameToDecode(scoped_ptr<transport::EncodedVideoFrame> video_frame,
       const base::TimeTicks& render_time) {
     EXPECT_TRUE(video_frame->key_frame);
-    EXPECT_EQ(kVp8, video_frame->codec);
+    EXPECT_EQ(transport::kVp8, video_frame->codec);
     ++num_called_;
   }
 
@@ -69,12 +69,12 @@ class VideoReceiverTest : public ::testing::Test {
  protected:
   VideoReceiverTest() {
     // Configure to use vp8 software implementation.
-    config_.codec = kVp8;
+    config_.codec = transport::kVp8;
     config_.use_external_decoder = false;
     task_runner_ = new test::FakeTaskRunner(&testing_clock_);
     cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
         task_runner_, task_runner_, task_runner_, task_runner_,
-        GetDefaultCastLoggingConfig());
+        task_runner_, GetDefaultCastLoggingConfig());
     receiver_.reset(new
         PeerVideoReceiver(cast_environment_, config_, &mock_transport_));
     testing_clock_.Advance(