Cast: Reshuffle files under media/cast

media/cast/sender/video_sender.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_sender.h"
+#include "media/cast/sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/rtcp/rtcp_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
-#include "media/cast/video_sender/external_video_encoder.h"
-#include "media/cast/video_sender/video_encoder_impl.h"
+#include "media/cast/net/cast_transport_config.h"
+#include "media/cast/net/rtcp/rtcp_defines.h"
+#include "media/cast/sender/external_video_encoder.h"
+#include "media/cast/sender/video_encoder_impl.h"
 
 namespace media {
 namespace cast {
 
 const int kNumAggressiveReportsSentAtStart = 100;
 const int kMinSchedulingDelayMs = 1;
 
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
-    transport::CastTransportSender* const transport_sender)
+    CastTransportSender* const transport_sender)
     : cast_environment_(cast_environment),
       target_playout_delay_(video_config.target_playout_delay),
       transport_sender_(transport_sender),
       max_unacked_frames_(
           std::min(kMaxUnackedFrames,
                    1 + static_cast<int>(target_playout_delay_ *
                                         video_config.max_frame_rate /
                                         base::TimeDelta::FromSeconds(1)))),
       rtcp_(cast_environment_,
             this,
@@ skipping 25 matching lines @@
     video_encoder_.reset(new ExternalVideoEncoder(cast_environment,
                                                   video_config,
                                                   create_vea_cb,
                                                   create_video_encode_mem_cb));
   } else {
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment, video_config, max_unacked_frames_));
   }
   cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
 
-  media::cast::transport::CastTransportRtpConfig transport_config;
+  media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.stored_frames = max_unacked_frames_;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
   transport_sender_->InitializeVideo(transport_config);
 
   rtcp_.SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
 
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
@@ skipping 46 matching lines @@
                      weak_factory_.GetWeakPtr(),
                      bitrate))) {
     frames_in_encoder_++;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
   }
 }
 
 void VideoSender::SendEncodedVideoFrame(
     int requested_bitrate_before_encode,
-    scoped_ptr<transport::EncodedFrame> encoded_frame) {
+    scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   DCHECK_GT(frames_in_encoder_, 0);
   frames_in_encoder_--;
 
   const uint32 frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
     ScheduleNextResendCheck();
   }
 
-  VLOG_IF(1, encoded_frame->dependency == transport::EncodedFrame::KEY)
+  VLOG_IF(1, encoded_frame->dependency == EncodedFrame::KEY)
       << "Send encoded key frame; frame_id: " << frame_id;
 
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, FRAME_ENCODED, VIDEO_EVENT, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
-      encoded_frame->dependency == transport::EncodedFrame::KEY,
+      encoded_frame->dependency == EncodedFrame::KEY,
       requested_bitrate_before_encode);
   // Only use lowest 8 bits as key.
   frame_id_to_rtp_timestamp_[frame_id & 0xff] = encoded_frame->rtp_timestamp;
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
       "rtp_timestamp", encoded_frame->rtp_timestamp);
 
@@ skipping 211 matching lines @@
   rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt);
 
   // Sending this extra packet is to kick-start the session. There is
   // no need to optimize re-transmission for this case.
   transport_sender_->ResendPackets(false, missing_frames_and_packets,
                                    false, rtt);
 }
 
 }  // namespace cast
 }  // namespace media