Cast: Reshuffle files under media/cast

media/cast/sender/external_video_encoder.cc

 // Copyright 2014 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/external_video_encoder.h"
+#include "media/cast/sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/logging/logging_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/net/cast_transport_config.h"
 #include "media/video/video_encode_accelerator.h"
 
 namespace media {
 namespace cast {
 class LocalVideoEncodeAcceleratorClient;
 }  // namespace cast
 }  // namespace media
 
 namespace {
 static const size_t kOutputBufferCount = 3;
@@ skipping 65 matching lines @@
     DCHECK(encoder_task_runner_);
   }
 
   // Initialize the real HW encoder.
   void Initialize(const VideoSenderConfig& video_config) {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
     VideoCodecProfile output_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
     switch (video_config.codec) {
-      case transport::CODEC_VIDEO_VP8:
+      case CODEC_VIDEO_VP8:
         output_profile = media::VP8PROFILE_MAIN;
         break;
-      case transport::CODEC_VIDEO_H264:
+      case CODEC_VIDEO_H264:
         output_profile = media::H264PROFILE_MAIN;
         break;
-      case transport::CODEC_VIDEO_FAKE:
+      case CODEC_VIDEO_FAKE:
         NOTREACHED() << "Fake software video encoder cannot be external";
         break;
       default:
         NOTREACHED() << "Video codec not specified or not supported";
         break;
     }
     max_frame_rate_ = video_config.max_frame_rate;
 
     if (!video_encode_accelerator_->Initialize(
             media::VideoFrame::I420,
@@ skipping 94 matching lines @@
     }
     if (key_frame)
       key_frame_encountered_ = true;
     if (!key_frame_encountered_) {
       // Do not send video until we have encountered the first key frame.
       // Save the bitstream buffer in |stream_header_| to be sent later along
       // with the first key frame.
       stream_header_.append(static_cast<const char*>(output_buffer->memory()),
                             payload_size);
     } else if (!encoded_frame_data_storage_.empty()) {
-      scoped_ptr<transport::EncodedFrame> encoded_frame(
-          new transport::EncodedFrame());
-      encoded_frame->dependency = key_frame ? transport::EncodedFrame::KEY :
-          transport::EncodedFrame::DEPENDENT;
+      scoped_ptr<EncodedFrame> encoded_frame(
+          new EncodedFrame());
+      encoded_frame->dependency = key_frame ? EncodedFrame::KEY :
+          EncodedFrame::DEPENDENT;
       encoded_frame->frame_id = ++last_encoded_frame_id_;
       if (key_frame)
         encoded_frame->referenced_frame_id = encoded_frame->frame_id;
       else
         encoded_frame->referenced_frame_id = encoded_frame->frame_id - 1;
       encoded_frame->reference_time =
           encoded_frame_data_storage_.front().capture_time;
       encoded_frame->rtp_timestamp =
           GetVideoRtpTimestamp(encoded_frame->reference_time);
       if (!stream_header_.empty()) {
@@ skipping 188 matching lines @@
   key_frame_requested_ = true;
 }
 
 // Inform the encoder to only reference frames older or equal to frame_id;
 void ExternalVideoEncoder::LatestFrameIdToReference(uint32 /*frame_id*/) {
   // Do nothing not supported.
 }
 
 }  //  namespace cast
 }  //  namespace media