src/chrome/browser/media/cast_transport_host_filter_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/callback.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/time/default_tick_clock.h"
   8 #include "chrome/browser/media/cast_transport_host_filter.h"
   9 #include "content/public/test/test_browser_thread_bundle.h"
  10 #include "media/cast/logging/logging_defines.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace {
  14
  15 class CastTransportHostFilterTest : public testing::Test {
  16  public:
  17   CastTransportHostFilterTest()
  18       : browser_thread_bundle_(
  19             content::TestBrowserThreadBundle::IO_MAINLOOP) {
  20     filter_ = new cast::CastTransportHostFilter();
  21     // 127.0.0.1:7 is the local echo service port, which
  22     // is probably not going to respond, but that's ok.
  23     // TODO(hubbe): Open up an UDP port and make sure
  24     // we can send and receive packets.
  25     net::IPAddressNumber receiver_address(4, 0);
  26     receiver_address[0] = 127;
  27     receiver_address[3] = 1;
  28     receive_endpoint_ = net::IPEndPoint(receiver_address, 7);
  29   }
  30
  31  protected:
  32   void FakeSend(const IPC::Message& message) {
  33     EXPECT_TRUE(filter_->OnMessageReceived(message));
  34   }
  35
  36   content::TestBrowserThreadBundle browser_thread_bundle_;
  37   scoped_refptr<content::BrowserMessageFilter> filter_;
  38   net::IPAddressNumber receiver_address_;
  39   net::IPEndPoint receive_endpoint_;
  40 };
  41
  42 TEST_F(CastTransportHostFilterTest, NewDelete) {
  43   const int kChannelId = 17;
  44   CastHostMsg_New new_msg(kChannelId, receive_endpoint_);
  45   CastHostMsg_Delete delete_msg(kChannelId);
  46
  47   // New, then delete, as expected.
  48   FakeSend(new_msg);
  49   FakeSend(delete_msg);
  50   FakeSend(new_msg);
  51   FakeSend(delete_msg);
  52   FakeSend(new_msg);
  53   FakeSend(delete_msg);
  54
  55   // Now create/delete transport senders in the wrong order to make sure
  56   // this doesn't crash.
  57   FakeSend(new_msg);
  58   FakeSend(new_msg);
  59   FakeSend(new_msg);
  60   FakeSend(delete_msg);
  61   FakeSend(delete_msg);
  62   FakeSend(delete_msg);
  63 }
  64
  65 TEST_F(CastTransportHostFilterTest, NewMany) {
  66   for (int i = 0; i < 100; i++) {
  67     CastHostMsg_New new_msg(i, receive_endpoint_);
  68     FakeSend(new_msg);
  69   }
  70
  71   for (int i = 0; i < 60; i++) {
  72     CastHostMsg_Delete delete_msg(i);
  73     FakeSend(delete_msg);
  74   }
  75
  76   // Leave some open, see what happens.
  77 }
  78
  79 TEST_F(CastTransportHostFilterTest, SimpleMessages) {
  80   // Create a cast transport sender.
  81   const int32 kChannelId = 42;
  82   CastHostMsg_New new_msg(kChannelId, receive_endpoint_);
  83   FakeSend(new_msg);
  84
  85   media::cast::CastTransportRtpConfig audio_config;
  86   audio_config.stored_frames = 10;
  87   audio_config.ssrc = 1;
  88   audio_config.feedback_ssrc = 2;
  89   CastHostMsg_InitializeAudio init_audio_msg(kChannelId, audio_config);
  90   FakeSend(init_audio_msg);
  91
  92   media::cast::CastTransportRtpConfig video_config;
  93   video_config.stored_frames = 10;
  94   video_config.ssrc = 11;
  95   video_config.feedback_ssrc = 12;
  96   CastHostMsg_InitializeVideo init_video_msg(kChannelId, video_config);
  97   FakeSend(init_video_msg);
  98
  99   media::cast::EncodedFrame audio_frame;
 100   audio_frame.dependency = media::cast::EncodedFrame::KEY;
 101   audio_frame.frame_id = 1;
 102   audio_frame.referenced_frame_id = 1;
 103   audio_frame.rtp_timestamp = 47;
 104   const int kSamples = 47;
 105   const int kBytesPerSample = 2;
 106   const int kChannels = 2;
 107   audio_frame.data = std::string(kSamples * kBytesPerSample * kChannels, 'q');
 108   CastHostMsg_InsertCodedAudioFrame insert_coded_audio_frame(
 109       kChannelId, audio_frame);
 110   FakeSend(insert_coded_audio_frame);
 111
 112   media::cast::EncodedFrame video_frame;
 113   video_frame.dependency = media::cast::EncodedFrame::KEY;
 114   video_frame.frame_id = 1;
 115   video_frame.referenced_frame_id = 1;
 116   // Let's make sure we try a few kb so multiple packets
 117   // are generated.
 118   const int kVideoDataSize = 4711;
 119   video_frame.data = std::string(kVideoDataSize, 'p');
 120   CastHostMsg_InsertCodedVideoFrame insert_coded_video_frame(
 121       kChannelId, video_frame);
 122   FakeSend(insert_coded_video_frame);
 123
 124   CastHostMsg_SendSenderReport rtcp_msg(
 125       kChannelId, 1, base::TimeTicks(), 2);
 126   FakeSend(rtcp_msg);
 127
 128   media::cast::MissingFramesAndPacketsMap missing_packets;
 129   missing_packets[1].insert(4);
 130   missing_packets[1].insert(7);
 131   CastHostMsg_ResendPackets resend_msg(
 132       kChannelId, false, missing_packets, true, base::TimeDelta());
 133   FakeSend(resend_msg);
 134
 135   CastHostMsg_Delete delete_msg(kChannelId);
 136   FakeSend(delete_msg);
 137 }
 138
 139 }  // namespace