Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/video_receiver/video_receiver.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_receiver/video_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 141 matching lines @@
 void VideoReceiver::GetRawVideoFrame(
     const VideoFrameDecodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   GetEncodedVideoFrame(base::Bind(&VideoReceiver::DecodeVideoFrame,
                                   base::Unretained(this), callback));
 }
 
 // Called when we have a frame to decode.
 void VideoReceiver::DecodeVideoFrame(
     const VideoFrameDecodedCallback& callback,
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+    scoped_ptr<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.
   cast_environment_->PostTask(CastEnvironment::VIDEO_DECODER, FROM_HERE,
       base::Bind(&VideoReceiver::DecodeVideoFrameThread, base::Unretained(this),
                  base::Passed(&encoded_frame), render_time, callback));
 }
 
 // Utility function to run the decoder on a designated decoding thread.
 void VideoReceiver::DecodeVideoFrameThread(
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
+    scoped_ptr<EncodedVideoFrame> encoded_frame,
     const base::TimeTicks render_time,
     const VideoFrameDecodedCallback& frame_decoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
   DCHECK(video_decoder_);
 
   if (!(video_decoder_->DecodeVideoFrame(encoded_frame.get(), render_time,
         frame_decoded_callback))) {
     // This will happen if we decide to decode but not show a frame.
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&VideoReceiver::GetRawVideoFrame, base::Unretained(this),
                    frame_decoded_callback));
   }
 }
 
 bool VideoReceiver::DecryptVideoFrame(
-    scoped_ptr<transport::EncodedVideoFrame>* video_frame) {
+    scoped_ptr<EncodedVideoFrame>* video_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(decryptor_) << "Invalid state";
 
   if (!decryptor_->SetCounter(GetAesNonce((*video_frame)->frame_id,
                                           iv_mask_))) {
     NOTREACHED() << "Failed to set counter";
     return false;
   }
   std::string decrypted_video_data;
   if (!decryptor_->Decrypt((*video_frame)->data, &decrypted_video_data)) {
     VLOG(1) << "Decryption error";
     // Give up on this frame, release it from jitter buffer.
     framer_->ReleaseFrame((*video_frame)->frame_id);
     return false;
   }
   (*video_frame)->data.swap(decrypted_video_data);
   return true;
 }
 
 // Called from the main cast thread.
 void VideoReceiver::GetEncodedVideoFrame(
     const VideoFrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-      new transport::EncodedVideoFrame());
+  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
   if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
 
@@ skipping 14 matching lines @@
     queued_encoded_callbacks_.push_back(callback);
   }
 }
 
 // Should we pull the encoded video frame from the framer? decided by if this is
 // the next frame or we are running out of time and have to pull the following
 // frame.
 // 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<transport::EncodedVideoFrame>* encoded_frame,
+    bool next_frame, scoped_ptr<EncodedVideoFrame>* encoded_frame,
     base::TimeTicks* render_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   *render_time = GetRenderTime(now, rtp_timestamp);
 
   // TODO(mikhal): Store actual render time and not diff.
   cast_environment_->Logging()->InsertFrameEventWithDelay(now,
       kVideoRenderDelay, rtp_timestamp, (*encoded_frame)->frame_id,
       now - *render_time);
 
@@ skipping 12 matching lines @@
         base::Bind(&VideoReceiver::PlayoutTimeout, weak_factory_.GetWeakPtr()),
         time_until_release);
     VLOG(1) << "Wait before releasing frame "
             << static_cast<int>((*encoded_frame)->frame_id)
             << " time " << time_until_release.InMilliseconds();
     return false;
   }
 
   base::TimeDelta dont_show_timeout_delta =
       base::TimeDelta::FromMilliseconds(-kDontShowTimeoutMs);
-  if (codec_ == transport::kVp8 &&
-      time_until_render < dont_show_timeout_delta) {
+  if (codec_ == 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)
             << " time_until_render:" << time_until_render.InMilliseconds();
   } else {
     VLOG(1) << "Show frame "
             << static_cast<int>((*encoded_frame)->frame_id)
             << " time_until_render:" << time_until_render.InMilliseconds();
   }
   // We have a copy of the frame, release this one.
   framer_->ReleaseFrame((*encoded_frame)->frame_id);
   (*encoded_frame)->codec = codec_;
   return true;
 }
 
 void VideoReceiver::PlayoutTimeout() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (queued_encoded_callbacks_.empty()) return;
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-      new transport::EncodedVideoFrame());
+  scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
 
   if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     // Since the application can post multiple VideoFrameEncodedCallback and
     // we only check the next frame to play out we might have multiple timeout
     // events firing after each other; however this should be a rare event.
     VLOG(1) << "Failed to retrieved a complete frame at this point in time";
     return;
   }
@@ skipping 160 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media