Cast:Adding cast_transport_config and cleaning up

media/cast/video_sender/video_encoder.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 "media/cast/video_sender/video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 
 namespace media {
 namespace cast {
 
 void LogFrameEncodedEvent(CastEnvironment* const cast_environment,
                           const base::TimeTicks& capture_time) {
   base::TimeTicks now = cast_environment->Clock()->NowTicks();
   cast_environment->Logging()->InsertFrameEvent(now, kVideoFrameEncoded,
       GetVideoRtpTimestamp(capture_time), kFrameIdUnknown);
 }
 
 VideoEncoder::VideoEncoder(scoped_refptr<CastEnvironment> cast_environment,
                            const VideoSenderConfig& video_config,
                            uint8 max_unacked_frames)
     : video_config_(video_config),
       cast_environment_(cast_environment),
       skip_next_frame_(false),
       skip_count_(0) {
-  if (video_config.codec == kVp8) {
+  if (video_config.codec == transport::kVp8) {
     vp8_encoder_.reset(new Vp8Encoder(video_config, max_unacked_frames));
   } else {
     DCHECK(false) << "Invalid config";  // Codec not supported.
   }
 
   dynamic_config_.key_frame_requested = false;
   dynamic_config_.latest_frame_id_to_reference = kStartFrameId;
   dynamic_config_.bit_rate = video_config.start_bitrate;
 }
 
 VideoEncoder::~VideoEncoder() {}
 
 bool VideoEncoder::EncodeVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  if (video_config_.codec != kVp8) return false;
+  if (video_config_.codec != transport::kVp8) return false;
 
   if (skip_next_frame_) {
     ++skip_count_;
     VLOG(1) << "Skip encoding frame";
     return false;
   }
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertFrameEvent(now, kVideoFrameSentToEncoder,
       GetVideoRtpTimestamp(capture_time), kFrameIdUnknown);
@@ skipping 12 matching lines @@
     const CodecDynamicConfig& dynamic_config,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_ENCODER));
   if (dynamic_config.key_frame_requested) {
     vp8_encoder_->GenerateKeyFrame();
   }
   vp8_encoder_->LatestFrameIdToReference(
       dynamic_config.latest_frame_id_to_reference);
   vp8_encoder_->UpdateRates(dynamic_config.bit_rate);
 
-  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
+  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
+      new transport::EncodedVideoFrame());
   bool retval = vp8_encoder_->Encode(video_frame, encoded_frame.get());
 
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(LogFrameEncodedEvent, cast_environment_, capture_time));
 
   if (!retval) {
     VLOG(1) << "Encoding failed";
     return;
   }
   if (encoded_frame->data.size() <= 0) {
@@ skipping 24 matching lines @@
 void VideoEncoder::LatestFrameIdToReference(uint32 frame_id) {
   dynamic_config_.latest_frame_id_to_reference = frame_id;
 }
 
 int VideoEncoder::NumberOfSkippedFrames() const {
   return skip_count_;
 }
 
 }  //  namespace cast
 }  //  namespace media