Cast:Adding cast_transport_config and cleaning up

media/cast/video_sender/video_sender_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/base/video_frame.h"
@@ skipping 51 matching lines @@
     video_config.use_external_encoder = external;
     video_config.width = kWidth;
     video_config.height = kHeight;
     video_config.max_bitrate = 5000000;
     video_config.min_bitrate = 1000000;
     video_config.start_bitrate = 1000000;
     video_config.max_qp = 56;
     video_config.min_qp = 0;
     video_config.max_frame_rate = 30;
     video_config.max_number_of_video_buffers_used = 1;
-    video_config.codec = kVp8;
+    video_config.codec = transport::kVp8;
 
     if (external) {
       video_sender_.reset(new PeerVideoSender(cast_environment_,
           video_config, &mock_video_encoder_controller_, &mock_transport_));
     } else {
       video_sender_.reset(new PeerVideoSender(cast_environment_, video_config,
                                               NULL, &mock_transport_));
     }
   }
 
   virtual void SetUp() {
     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_, task_runner_, task_runner_, task_runner_,
+        task_runner_, GetDefaultCastLoggingConfig());
   }
 
   scoped_refptr<media::VideoFrame> GetNewVideoFrame() {
     gfx::Size size(kWidth, kHeight);
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(VideoFrame::I420, size, gfx::Rect(size),
                                        size, base::TimeDelta());
     PopulateVideoFrame(video_frame, kPixelValue);
     return video_frame;
   }
@@ skipping 16 matching lines @@
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
   EXPECT_CALL(mock_transport_, SendPackets(_)).Times(1);
   EXPECT_CALL(mock_video_encoder_controller_, SkipNextFrame(false)).Times(1);
   InitEncoder(true);
 
-  EncodedVideoFrame video_frame;
+  transport::EncodedVideoFrame video_frame;
   base::TimeTicks capture_time;
 
-  video_frame.codec = kVp8;
+  video_frame.codec = transport::kVp8;
   video_frame.key_frame = true;
   video_frame.frame_id = 0;
   video_frame.last_referenced_frame_id = 0;
   video_frame.data.insert(video_frame.data.begin(), 1000, kPixelValue);
 
   video_sender_->InsertCodedVideoFrame(&video_frame, capture_time,
     base::Bind(base::DoNothing));
 }
 
 TEST_F(VideoSenderTest, RtcpTimer) {
   EXPECT_CALL(mock_transport_, SendPackets(_)).Times(AtLeast(1));
   EXPECT_CALL(mock_transport_, SendRtcpPacket(_)).Times(1);
   EXPECT_CALL(mock_video_encoder_controller_,
               SkipNextFrame(false)).Times(AtLeast(1));
   InitEncoder(true);
 
-  EncodedVideoFrame video_frame;
+  transport::EncodedVideoFrame video_frame;
   base::TimeTicks capture_time;
 
-  video_frame.codec = kVp8;
+  video_frame.codec = transport::kVp8;
   video_frame.key_frame = true;
   video_frame.frame_id = 0;
   video_frame.last_referenced_frame_id = 0;
   video_frame.data.insert(video_frame.data.begin(), 1000, kPixelValue);
 
   video_sender_->InsertCodedVideoFrame(&video_frame, capture_time,
     base::Bind(base::DoNothing));
 
   // Make sure that we send at least one RTCP packet.
   base::TimeDelta max_rtcp_timeout =
@@ skipping 31 matching lines @@
       base::TimeDelta::FromMilliseconds(1 + kDefaultRtpMaxDelayMs);
 
   // Make sure that we do a re-send.
   testing_clock_.Advance(max_resend_timeout);
   task_runner_->RunTasks();
 }
 
 }  // namespace cast
 }  // namespace media