Cast: move net->transport

media/cast/rtcp/rtcp_receiver_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 "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/net/cast_net_defines.h"
 #include "media/cast/rtcp/mock_rtcp_receiver_feedback.h"
 #include "media/cast/rtcp/mock_rtcp_sender_feedback.h"
 #include "media/cast/rtcp/rtcp_receiver.h"
 #include "media/cast/rtcp/rtcp_utility.h"
 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
 #include "media/cast/test/fake_task_runner.h"
+#include "media/cast/transport/cast_transport_defines.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 namespace cast {
 
 using testing::_;
 
 static const uint32 kSenderSsrc = 0x10203;
 static const uint32 kSourceSsrc = 0x40506;
 static const uint32 kUnknownSsrc = 0xDEAD;
@@ skipping 36 matching lines @@
   bool called_;
 };
 
 class RtcpReceiverCastLogVerification : public RtcpReceiverFeedback {
  public:
   RtcpReceiverCastLogVerification()
       : called_on_received_sender_log_(false),
         called_on_received_receiver_log_(false) {}
 
   virtual void OnReceivedSenderReport(
-      const RtcpSenderInfo& remote_sender_info) OVERRIDE {};
+      const transport::RtcpSenderInfo& remote_sender_info) OVERRIDE {};
 
   virtual void OnReceiverReferenceTimeReport(
       const RtcpReceiverReferenceTimeReport& remote_time_report) OVERRIDE {};
 
   virtual void OnReceivedSendReportRequest() OVERRIDE {};
 
   virtual void OnReceivedReceiverLog(
       const RtcpReceiverLogMessage& receiver_log) OVERRIDE {
     EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size());
     RtcpReceiverLogMessage::const_iterator expected_it =
@@ skipping 20 matching lines @@
                     event_incoming_it->delay_delta);
         }
       }
       expected_receiver_log_.pop_front();
       expected_it = expected_receiver_log_.begin();
     }
     called_on_received_receiver_log_ = true;
   }
 
   virtual void OnReceivedSenderLog(
-      const RtcpSenderLogMessage& sender_log) OVERRIDE {
+      const transport::RtcpSenderLogMessage& sender_log) OVERRIDE {
     EXPECT_EQ(expected_sender_log_.size(), sender_log.size());
 
-    RtcpSenderLogMessage::const_iterator expected_it =
+    transport::RtcpSenderLogMessage::const_iterator expected_it =
        expected_sender_log_.begin();
-    RtcpSenderLogMessage::const_iterator incoming_it = sender_log.begin();
+    transport::RtcpSenderLogMessage::const_iterator incoming_it =
+        sender_log.begin();
     for (; expected_it != expected_sender_log_.end();
         ++expected_it, ++incoming_it) {
       EXPECT_EQ(expected_it->frame_status, incoming_it->frame_status);
       EXPECT_EQ(0xffffff & expected_it->rtp_timestamp,
                 incoming_it->rtp_timestamp);
     }
     called_on_received_sender_log_ = true;
   }
 
   bool OnReceivedSenderLogCalled() {
     return called_on_received_sender_log_;
   }
 
   bool OnReceivedReceiverLogCalled() {
     return called_on_received_receiver_log_ && expected_receiver_log_.empty();
   }
 
   void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
     expected_receiver_log_ = receiver_log;
   }
 
-  void SetExpectedSenderLog(const RtcpSenderLogMessage& sender_log) {
+  void SetExpectedSenderLog(const transport::RtcpSenderLogMessage& sender_log) {
     expected_sender_log_ = sender_log;
   }
 
  private:
   RtcpReceiverLogMessage expected_receiver_log_;
-  RtcpSenderLogMessage expected_sender_log_;
+  transport::RtcpSenderLogMessage expected_sender_log_;
   bool called_on_received_sender_log_;
   bool called_on_received_receiver_log_;
 };
 
 }  // namespace
 
 class RtcpReceiverTest : public ::testing::Test {
  protected:
   RtcpReceiverTest()
       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
@@ skipping 44 matching lines @@
     rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
   }
 
   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
   MockRtcpReceiverFeedback mock_receiver_feedback_;
   MockRtcpRttFeedback mock_rtt_feedback_;
   MockRtcpSenderFeedback mock_sender_feedback_;
   scoped_ptr<RtcpReceiver> rtcp_receiver_;
-  RtcpSenderInfo expected_sender_info_;
-  RtcpReportBlock expected_report_block_;
+  transport::RtcpSenderInfo expected_sender_info_;
+  transport::RtcpReportBlock expected_report_block_;
   RtcpReceiverReferenceTimeReport expected_receiver_reference_report_;
 };
 
 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
   const uint8 bad_packet[] = {0, 0, 0, 0};
   InjectRtcpPacket(bad_packet, sizeof(bad_packet));
 }
 
 TEST_F(RtcpReceiverTest, InjectSenderReportPacket) {
   TestRtcpPacketBuilder p;
@@ skipping 228 matching lines @@
 
 TEST_F(RtcpReceiverTest, InjectSenderReportWithCastSenderLogVerification) {
   RtcpReceiverCastLogVerification cast_log_verification;
   RtcpReceiver rtcp_receiver(cast_environment_,
                              &mock_sender_feedback_,
                              &cast_log_verification,
                              &mock_rtt_feedback_,
                              kSourceSsrc);
   rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
 
-  RtcpSenderLogMessage sender_log;
+  transport::RtcpSenderLogMessage sender_log;
   for (int j = 0; j < 359; ++j) {
-    RtcpSenderFrameLogMessage sender_frame_log;
-    sender_frame_log.frame_status = kRtcpSenderFrameStatusSentToNetwork;
+    transport::RtcpSenderFrameLogMessage sender_frame_log;
+    sender_frame_log.frame_status =
+        transport::kRtcpSenderFrameStatusSentToNetwork;
     sender_frame_log.rtp_timestamp = kRtpTimestamp + j * 90;
     sender_log.push_back(sender_frame_log);
   }
   cast_log_verification.SetExpectedSenderLog(sender_log);
 
   TestRtcpPacketBuilder p;
   p.AddSr(kSenderSsrc, 0);
   p.AddSdesCname(kSenderSsrc, kCName);
   p.AddSenderLog(kSenderSsrc);
 
   for (int i = 0; i < 359; ++i) {
-    p.AddSenderFrameLog(kRtcpSenderFrameStatusSentToNetwork,
+    p.AddSenderFrameLog(transport::kRtcpSenderFrameStatusSentToNetwork,
                         kRtpTimestamp + i * 90);
   }
   RtcpParser rtcp_parser(p.Packet(), p.Length());
   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 
   EXPECT_TRUE(cast_log_verification.OnReceivedSenderLogCalled());
 }
 
 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) {
   static const uint32 kTimeBaseMs = 12345678;
@@ skipping 88 matching lines @@
   EXPECT_CALL(mock_rtt_feedback_,
       OnReceivedDelaySinceLastReport(kSourceSsrc, kLastSr, kDelayLastSr)).
           Times(1);
 
   RtcpParser rtcp_parser(p.Packet(), p.Length());
   rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
 
   EXPECT_TRUE(cast_log_verification.OnReceivedReceiverLogCalled());
 }
 
-
-
 }  // namespace cast
 }  // namespace media