Cast: Reshuffle files under media/cast

media/cast/net/rtcp/rtcp_unittest.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 <stdint.h>
 
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/rtcp/mock_rtcp_receiver_feedback.h"
-#include "media/cast/rtcp/mock_rtcp_sender_feedback.h"
-#include "media/cast/rtcp/rtcp.h"
-#include "media/cast/rtcp/test_rtcp_packet_builder.h"
+#include "media/cast/net/cast_transport_config.h"
+#include "media/cast/net/cast_transport_sender_impl.h"
+#include "media/cast/net/pacing/paced_sender.h"
+#include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h"
+#include "media/cast/net/rtcp/mock_rtcp_sender_feedback.h"
+#include "media/cast/net/rtcp/rtcp.h"
+#include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
-#include "media/cast/transport/cast_transport_config.h"
-#include "media/cast/transport/cast_transport_sender_impl.h"
-#include "media/cast/transport/pacing/paced_sender.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 using testing::_;
 
 static const uint32 kSenderSsrc = 0x10203;
 static const uint32 kReceiverSsrc = 0x40506;
 static const std::string kCName("test@10.1.1.1");
 static const uint32 kRtcpIntervalMs = 500;
 static const int64 kAddedDelay = 123;
 static const int64 kAddedShortDelay = 100;
 
-class RtcpTestPacketSender : public transport::PacketSender {
+class RtcpTestPacketSender : public PacketSender {
  public:
   explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock)
       : drop_packets_(false),
         short_delay_(false),
         rtcp_receiver_(NULL),
         testing_clock_(testing_clock) {}
   virtual ~RtcpTestPacketSender() {}
   // Packet lists imply a RTP packet.
   void set_rtcp_receiver(Rtcp* rtcp) { rtcp_receiver_ = rtcp; }
 
   void set_short_delay() { short_delay_ = true; }
 
   void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; }
 
   // A singular packet implies a RTCP packet.
-  virtual bool SendPacket(transport::PacketRef packet,
+  virtual bool SendPacket(PacketRef packet,
                           const base::Closure& cb) OVERRIDE {
     if (short_delay_) {
       testing_clock_->Advance(
           base::TimeDelta::FromMilliseconds(kAddedShortDelay));
     } else {
       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay));
     }
     if (drop_packets_)
       return true;
 
     rtcp_receiver_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
     return true;
   }
 
  private:
   bool drop_packets_;
   bool short_delay_;
   Rtcp* rtcp_receiver_;
   base::SimpleTestTickClock* testing_clock_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender);
 };
 
-class LocalRtcpTransport : public transport::PacedPacketSender {
+class LocalRtcpTransport : public PacedPacketSender {
  public:
   LocalRtcpTransport(scoped_refptr<CastEnvironment> cast_environment,
                      base::SimpleTestTickClock* testing_clock)
       : drop_packets_(false),
         short_delay_(false),
         testing_clock_(testing_clock) {}
 
   void set_rtcp_receiver(Rtcp* rtcp) { rtcp_ = rtcp; }
 
   void set_short_delay() { short_delay_ = true; }
 
   void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; }
 
   virtual bool SendRtcpPacket(uint32 ssrc,
-                              transport::PacketRef packet) OVERRIDE {
+                              PacketRef packet) OVERRIDE {
     if (short_delay_) {
       testing_clock_->Advance(
           base::TimeDelta::FromMilliseconds(kAddedShortDelay));
     } else {
       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay));
     }
     if (drop_packets_)
       return true;
 
     rtcp_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
     return true;
   }
 
   virtual bool SendPackets(
-      const transport::SendPacketVector& packets) OVERRIDE {
+      const SendPacketVector& packets) OVERRIDE {
     return false;
   }
 
   virtual bool ResendPackets(
-      const transport::SendPacketVector& packets,
+      const SendPacketVector& packets,
       base::TimeDelta dedupe_window) OVERRIDE {
     return false;
   }
 
   virtual void CancelSendingPacket(
-      const transport::PacketKey& packet_key) OVERRIDE {
+      const PacketKey& packet_key) OVERRIDE {
   }
 
  private:
   bool drop_packets_;
   bool short_delay_;
   Rtcp* rtcp_;
   base::SimpleTestTickClock* testing_clock_;
   scoped_refptr<CastEnvironment> cast_environment_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport);
 };
 
 class RtcpPeer : public Rtcp {
  public:
   RtcpPeer(scoped_refptr<CastEnvironment> cast_environment,
            RtcpSenderFeedback* sender_feedback,
-           transport::CastTransportSender* const transport_sender,
-           transport::PacedPacketSender* paced_packet_sender,
+           CastTransportSender* const transport_sender,
+           PacedPacketSender* paced_packet_sender,
            RtpReceiverStatistics* rtp_receiver_statistics,
            RtcpMode rtcp_mode,
            const base::TimeDelta& rtcp_interval,
            uint32 local_ssrc,
            uint32 remote_ssrc,
            const std::string& c_name)
       : Rtcp(cast_environment,
              sender_feedback,
              transport_sender,
              paced_packet_sender,
@@ skipping 16 matching lines @@
         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
         cast_environment_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_)),
         sender_to_receiver_(testing_clock_),
         receiver_to_sender_(cast_environment_, testing_clock_) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
     net::IPEndPoint dummy_endpoint;
-    transport_sender_.reset(new transport::CastTransportSenderImpl(
+    transport_sender_.reset(new CastTransportSenderImpl(
         NULL,
         testing_clock_,
         dummy_endpoint,
         base::Bind(&UpdateCastTransportStatus),
-        transport::BulkRawEventsCallback(),
+        BulkRawEventsCallback(),
         base::TimeDelta(),
         task_runner_,
         &sender_to_receiver_));
-    transport::CastTransportRtpConfig config;
+    CastTransportRtpConfig config;
     config.ssrc = kSenderSsrc;
     config.rtp_payload_type = 127;
     config.stored_frames = 1;
     transport_sender_->InitializeAudio(config);
     EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0);
   }
 
   virtual ~RtcpTest() {}
 
-  static void UpdateCastTransportStatus(transport::CastTransportStatus status) {
-    bool result = (status == transport::TRANSPORT_AUDIO_INITIALIZED ||
-                   status == transport::TRANSPORT_VIDEO_INITIALIZED);
+  static void UpdateCastTransportStatus(CastTransportStatus status) {
+    bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
+                   status == TRANSPORT_VIDEO_INITIALIZED);
     EXPECT_TRUE(result);
   }
 
   void RunTasks(int during_ms) {
     for (int i = 0; i < during_ms; ++i) {
       // Call process the timers every 1 ms.
       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
       task_runner_->RunTasks();
     }
   }
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
   RtcpTestPacketSender sender_to_receiver_;
-  scoped_ptr<transport::CastTransportSenderImpl> transport_sender_;
+  scoped_ptr<CastTransportSenderImpl> transport_sender_;
   LocalRtcpTransport receiver_to_sender_;
   MockRtcpSenderFeedback mock_sender_feedback_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
 TEST_F(RtcpTest, TimeToSend) {
   const base::TimeTicks start_time = testing_clock_->NowTicks();
   Rtcp rtcp(cast_environment_,
             &mock_sender_feedback_,
@@ skipping 324 matching lines @@
   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_3 - out_2), time_delta);
   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 }
 
 }  // namespace cast
 }  // namespace media