Cast: Reshuffle files under media/cast

media/cast/test/cast_benchmarks.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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
@@ skipping 27 matching lines @@
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/simple_event_subscriber.h"
+#include "media/cast/net/cast_transport_config.h"
+#include "media/cast/net/cast_transport_defines.h"
+#include "media/cast/net/cast_transport_sender.h"
+#include "media/cast/net/cast_transport_sender_impl.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/loopback_transport.h"
 #include "media/cast/test/skewed_single_thread_task_runner.h"
 #include "media/cast/test/skewed_tick_clock.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/test_util.h"
 #include "media/cast/test/utility/udp_proxy.h"
 #include "media/cast/test/utility/video_utility.h"
-#include "media/cast/transport/cast_transport_config.h"
-#include "media/cast/transport/cast_transport_defines.h"
-#include "media/cast/transport/cast_transport_sender.h"
-#include "media/cast/transport/cast_transport_sender_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 static const int64 kStartMillisecond = INT64_C(1245);
 static const int kAudioChannels = 2;
 static const int kVideoHdWidth = 1280;
 static const int kVideoHdHeight = 720;
 static const int kTargetPlayoutDelayMs = 300;
 
 // The tests are commonly implemented with |kFrameTimerMs| RunTask function;
 // a normal video is 30 fps hence the 33 ms between frames.
 static const int kFrameTimerMs = 33;
 
-void UpdateCastTransportStatus(transport::CastTransportStatus status) {
-  bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
-                 status == transport::TRANSPORT_VIDEO_INITIALIZED);
+void UpdateCastTransportStatus(CastTransportStatus status) {
+  bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
+                 status == TRANSPORT_VIDEO_INITIALIZED);
   EXPECT_TRUE(result);
 }
 
 void AudioInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_AUDIO_INITIALIZED, status);
 }
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
 }
 
 void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events) {
 }
 
 }  // namespace
 
 // Wraps a CastTransportSender and records some statistics about
 // the data that goes through it.
-class CastTransportSenderWrapper : public transport::CastTransportSender {
+class CastTransportSenderWrapper : public CastTransportSender {
  public:
   // Takes ownership of |transport|.
   void Init(CastTransportSender* transport,
             uint64* encoded_video_bytes,
             uint64* encoded_audio_bytes) {
     transport_.reset(transport);
     encoded_video_bytes_ = encoded_video_bytes;
     encoded_audio_bytes_ = encoded_audio_bytes;
   }
 
   virtual void InitializeAudio(
-      const transport::CastTransportRtpConfig& config) OVERRIDE {
+      const CastTransportRtpConfig& config) OVERRIDE {
     transport_->InitializeAudio(config);
   }
 
   virtual void InitializeVideo(
-      const transport::CastTransportRtpConfig& config) OVERRIDE {
+      const CastTransportRtpConfig& config) OVERRIDE {
     transport_->InitializeVideo(config);
   }
 
   virtual void SetPacketReceiver(
-      const transport::PacketReceiverCallback& packet_receiver) OVERRIDE {
+      const PacketReceiverCallback& packet_receiver) OVERRIDE {
     transport_->SetPacketReceiver(packet_receiver);
   }
 
   virtual void InsertCodedAudioFrame(
-      const transport::EncodedFrame& audio_frame) OVERRIDE {
+      const EncodedFrame& audio_frame) OVERRIDE {
     *encoded_audio_bytes_ += audio_frame.data.size();
     transport_->InsertCodedAudioFrame(audio_frame);
   }
 
   virtual void InsertCodedVideoFrame(
-      const transport::EncodedFrame& video_frame) OVERRIDE {
+      const EncodedFrame& video_frame) OVERRIDE {
     *encoded_video_bytes_ += video_frame.data.size();
     transport_->InsertCodedVideoFrame(video_frame);
   }
 
   virtual void SendRtcpFromRtpSender(uint32 packet_type_flags,
                                      uint32 ntp_seconds,
                                      uint32 ntp_fraction,
                                      uint32 rtp_timestamp,
-                                     const transport::RtcpDlrrReportBlock& dlrr,
+                                     const RtcpDlrrReportBlock& dlrr,
                                      uint32 sending_ssrc,
                                      const std::string& c_name) OVERRIDE {
     transport_->SendRtcpFromRtpSender(packet_type_flags,
                                       ntp_seconds,
                                       ntp_fraction,
                                       rtp_timestamp,
                                       dlrr,
                                       sending_ssrc,
                                       c_name);
   }
 
   // Retransmission request.
   virtual void ResendPackets(
       bool is_audio,
       const MissingFramesAndPacketsMap& missing_packets,
       bool cancel_rtx_if_not_in_list,
       base::TimeDelta dedupe_window) OVERRIDE {
     transport_->ResendPackets(
         is_audio, missing_packets, cancel_rtx_if_not_in_list, dedupe_window);
   }
 
  private:
-  scoped_ptr<transport::CastTransportSender> transport_;
+  scoped_ptr<CastTransportSender> transport_;
   uint64* encoded_video_bytes_;
   uint64* encoded_audio_bytes_;
 };
 
 struct MeasuringPoint {
   MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
       : bitrate(bitrate_),
         latency(latency_),
         percent_packet_drop(percent_packet_drop_) {}
   bool operator<=(const MeasuringPoint& other) const {
@@ skipping 38 matching lines @@
             task_runner_receiver_)),
         receiver_to_sender_(cast_environment_receiver_),
         sender_to_receiver_(cast_environment_sender_),
         video_bytes_encoded_(0),
         audio_bytes_encoded_(0),
         frames_sent_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
-  void Configure(transport::Codec video_codec,
-                 transport::Codec audio_codec,
+  void Configure(Codec video_codec,
+                 Codec audio_codec,
                  int audio_sampling_frequency,
                  int max_number_of_video_buffers_used) {
     audio_sender_config_.ssrc = 1;
     audio_sender_config_.incoming_feedback_ssrc = 2;
     audio_sender_config_.target_playout_delay =
         base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     audio_sender_config_.rtp_payload_type = 96;
     audio_sender_config_.use_external_encoder = false;
     audio_sender_config_.frequency = audio_sampling_frequency;
     audio_sender_config_.channels = kAudioChannels;
@@ skipping 56 matching lines @@
     testing_clock_receiver_->SetSkew(skew, offset);
     task_runner_receiver_->SetSkew(1.0 / skew);
   }
 
   void Create(const MeasuringPoint& p) {
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
                                           &receiver_to_sender_);
     net::IPEndPoint dummy_endpoint;
-    transport_sender_.Init(new transport::CastTransportSenderImpl(
+    transport_sender_.Init(new CastTransportSenderImpl(
                                NULL,
                                testing_clock_sender_,
                                dummy_endpoint,
                                base::Bind(&UpdateCastTransportStatus),
                                base::Bind(&IgnoreRawEvents),
                                base::TimeDelta::FromSeconds(1),
                                task_runner_sender_,
                                &sender_to_receiver_),
                            &video_bytes_encoded_,
                            &audio_bytes_encoded_);
@@ skipping 64 matching lines @@
     scoped_ptr<test::PacketPipe> pipe = test::NewBuffer(65536, p.bitrate);
     pipe->AppendToPipe(
         test::NewRandomDrop(p.percent_packet_drop / 100.0).Pass());
     pipe->AppendToPipe(test::NewConstantDelay(p.latency / 1000.0));
     return pipe.Pass();
   }
 
   void Run(const MeasuringPoint& p) {
     available_bitrate_ = p.bitrate;
     Configure(
-        transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000, 1);
+        CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16, 32000, 1);
     Create(p);
     StartBasicPlayer();
 
     for (int frame = 0; frame < 1000; frame++) {
       SendFakeVideoFrame();
       RunTasks(kFrameTimerMs);
     }
     RunTasks(100 * kFrameTimerMs);  // Empty the pipeline.
     VLOG(1) << "=============INPUTS============";
     VLOG(1) << "Bitrate: " << p.bitrate << " mbit/s";
@@ skipping 310 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }