src/media/cast/logging/encoding_event_subscriber_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/memory/ref_counted.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/test/simple_test_tick_clock.h"
   8 #include "base/time/tick_clock.h"
   9 #include "media/cast/cast_environment.h"
  10 #include "media/cast/logging/encoding_event_subscriber.h"
  11 #include "media/cast/logging/logging_defines.h"
  12 #include "media/cast/test/fake_single_thread_task_runner.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using media::cast::proto::AggregatedFrameEvent;
  16 using media::cast::proto::AggregatedPacketEvent;
  17 using media::cast::proto::BasePacketEvent;
  18 using media::cast::proto::LogMetadata;
  19
  20 namespace {
  21
  22 int64 InMilliseconds(base::TimeTicks event_time) {
  23   return (event_time - base::TimeTicks()).InMilliseconds();
  24 }
  25
  26 }
  27
  28 namespace media {
  29 namespace cast {
  30
  31 class EncodingEventSubscriberTest : public ::testing::Test {
  32  protected:
  33   EncodingEventSubscriberTest()
  34       : testing_clock_(new base::SimpleTestTickClock()),
  35         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
  36         cast_environment_(new CastEnvironment(
  37             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
  38             task_runner_,
  39             task_runner_,
  40             task_runner_)),
  41         first_rtp_timestamp_(0) {}
  42
  43   void Init(EventMediaType event_media_type) {
  44     DCHECK(!event_subscriber_);
  45     event_subscriber_.reset(new EncodingEventSubscriber(event_media_type, 10));
  46     cast_environment_->Logging()->AddRawEventSubscriber(
  47         event_subscriber_.get());
  48   }
  49
  50   virtual ~EncodingEventSubscriberTest() {
  51     if (event_subscriber_) {
  52       cast_environment_->Logging()->RemoveRawEventSubscriber(
  53           event_subscriber_.get());
  54     }
  55   }
  56
  57   void GetEventsAndReset() {
  58     event_subscriber_->GetEventsAndReset(
  59         &metadata_, &frame_events_, &packet_events_);
  60     first_rtp_timestamp_ = metadata_.first_rtp_timestamp();
  61   }
  62
  63   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
  64   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
  65   scoped_refptr<CastEnvironment> cast_environment_;
  66   scoped_ptr<EncodingEventSubscriber> event_subscriber_;
  67   FrameEventList frame_events_;
  68   PacketEventList packet_events_;
  69   LogMetadata metadata_;
  70   RtpTimestamp first_rtp_timestamp_;
  71 };
  72
  73 TEST_F(EncodingEventSubscriberTest, FrameEventTruncating) {
  74   Init(VIDEO_EVENT);
  75
  76   base::TimeTicks now(testing_clock_->NowTicks());
  77
  78   // Entry with RTP timestamp 0 should get dropped.
  79   for (int i = 0; i < 11; i++) {
  80     cast_environment_->Logging()->InsertFrameEvent(now,
  81                                                    kVideoFrameCaptureBegin,
  82                                                    i * 100,
  83                                                    /*frame_id*/ 0);
  84     cast_environment_->Logging()->InsertFrameEvent(now,
  85                                                    kVideoFrameDecoded,
  86                                                    i * 100,
  87                                                    /*frame_id*/ 0);
  88   }
  89
  90   GetEventsAndReset();
  91
  92   ASSERT_EQ(10u, frame_events_.size());
  93   EXPECT_EQ(100u, frame_events_.front()->relative_rtp_timestamp());
  94   EXPECT_EQ(1000u, frame_events_.back()->relative_rtp_timestamp());
  95 }
  96
  97 TEST_F(EncodingEventSubscriberTest, PacketEventTruncating) {
  98   Init(AUDIO_EVENT);
  99
 100   base::TimeTicks now(testing_clock_->NowTicks());
 101
 102   // Entry with RTP timestamp 0 should get dropped.
 103   for (int i = 0; i < 11; i++) {
 104     cast_environment_->Logging()->InsertPacketEvent(now,
 105                                                     kAudioPacketReceived,
 106                                                     /*rtp_timestamp*/ i * 100,
 107                                                     /*frame_id*/ 0,
 108                                                     /*packet_id*/ i,
 109                                                     /*max_packet_id*/ 10,
 110                                                     /*size*/ 123);
 111   }
 112
 113   GetEventsAndReset();
 114
 115   ASSERT_EQ(10u, packet_events_.size());
 116   EXPECT_EQ(100u, packet_events_.front()->relative_rtp_timestamp());
 117   EXPECT_EQ(1000u, packet_events_.back()->relative_rtp_timestamp());
 118 }
 119
 120 TEST_F(EncodingEventSubscriberTest, EventFiltering) {
 121   Init(VIDEO_EVENT);
 122
 123   base::TimeTicks now(testing_clock_->NowTicks());
 124   RtpTimestamp rtp_timestamp = 100;
 125   cast_environment_->Logging()->InsertFrameEvent(now,
 126                                                  kVideoFrameDecoded,
 127                                                  rtp_timestamp,
 128                                                  /*frame_id*/ 0);
 129
 130   // This is an AUDIO_EVENT and shouldn't be processed by the subscriber.
 131   cast_environment_->Logging()->InsertFrameEvent(now,
 132                                                  kAudioFrameDecoded,
 133                                                  rtp_timestamp,
 134                                                  /*frame_id*/ 0);
 135
 136   GetEventsAndReset();
 137
 138   ASSERT_EQ(1u, frame_events_.size());
 139   FrameEventList::iterator it = frame_events_.begin();
 140
 141   linked_ptr<AggregatedFrameEvent> frame_event = *it;
 142
 143   ASSERT_EQ(1, frame_event->event_type_size());
 144   EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED,
 145             frame_event->event_type(0));
 146
 147   GetEventsAndReset();
 148
 149   EXPECT_TRUE(packet_events_.empty());
 150 }
 151
 152 TEST_F(EncodingEventSubscriberTest, FrameEvent) {
 153   Init(VIDEO_EVENT);
 154   base::TimeTicks now(testing_clock_->NowTicks());
 155   RtpTimestamp rtp_timestamp = 100;
 156   cast_environment_->Logging()->InsertFrameEvent(now, kVideoFrameDecoded,
 157                                                  rtp_timestamp,
 158                                                  /*frame_id*/ 0);
 159
 160   GetEventsAndReset();
 161
 162   ASSERT_EQ(1u, frame_events_.size());
 163
 164   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 165   FrameEventList::iterator it = frame_events_.begin();
 166
 167   linked_ptr<AggregatedFrameEvent> event = *it;
 168
 169   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 170
 171   ASSERT_EQ(1, event->event_type_size());
 172   EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED, event->event_type(0));
 173   ASSERT_EQ(1, event->event_timestamp_ms_size());
 174   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 175
 176   EXPECT_EQ(0, event->encoded_frame_size());
 177   EXPECT_EQ(0, event->delay_millis());
 178
 179   GetEventsAndReset();
 180   EXPECT_TRUE(frame_events_.empty());
 181 }
 182
 183 TEST_F(EncodingEventSubscriberTest, FrameEventDelay) {
 184   Init(AUDIO_EVENT);
 185   base::TimeTicks now(testing_clock_->NowTicks());
 186   RtpTimestamp rtp_timestamp = 100;
 187   int delay_ms = 100;
 188   cast_environment_->Logging()->InsertFrameEventWithDelay(
 189       now, kAudioPlayoutDelay, rtp_timestamp,
 190       /*frame_id*/ 0, base::TimeDelta::FromMilliseconds(delay_ms));
 191
 192   GetEventsAndReset();
 193
 194   ASSERT_EQ(1u, frame_events_.size());
 195
 196   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 197   FrameEventList::iterator it = frame_events_.begin();
 198
 199   linked_ptr<AggregatedFrameEvent> event = *it;
 200
 201   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 202
 203   ASSERT_EQ(1, event->event_type_size());
 204   EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
 205   ASSERT_EQ(1, event->event_timestamp_ms_size());
 206   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 207
 208   EXPECT_EQ(0, event->encoded_frame_size());
 209   EXPECT_EQ(100, event->delay_millis());
 210   EXPECT_FALSE(event->has_key_frame());
 211 }
 212
 213 TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
 214   Init(VIDEO_EVENT);
 215   base::TimeTicks now(testing_clock_->NowTicks());
 216   RtpTimestamp rtp_timestamp = 100;
 217   int size = 123;
 218   bool key_frame = true;
 219   int target_bitrate = 1024;
 220   cast_environment_->Logging()->InsertEncodedFrameEvent(
 221       now, kVideoFrameEncoded, rtp_timestamp,
 222       /*frame_id*/ 0, size, key_frame, target_bitrate);
 223
 224   GetEventsAndReset();
 225
 226   ASSERT_EQ(1u, frame_events_.size());
 227
 228   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 229   FrameEventList::iterator it = frame_events_.begin();
 230
 231   linked_ptr<AggregatedFrameEvent> event = *it;
 232
 233   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 234
 235   ASSERT_EQ(1, event->event_type_size());
 236   EXPECT_EQ(media::cast::proto::VIDEO_FRAME_ENCODED, event->event_type(0));
 237   ASSERT_EQ(1, event->event_timestamp_ms_size());
 238   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 239
 240   EXPECT_EQ(size, event->encoded_frame_size());
 241   EXPECT_EQ(0, event->delay_millis());
 242   EXPECT_TRUE(event->has_key_frame());
 243   EXPECT_EQ(key_frame, event->key_frame());
 244   EXPECT_EQ(target_bitrate, event->target_bitrate());
 245 }
 246
 247 TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
 248   Init(AUDIO_EVENT);
 249   RtpTimestamp rtp_timestamp1 = 100;
 250   RtpTimestamp rtp_timestamp2 = 200;
 251   base::TimeTicks now1(testing_clock_->NowTicks());
 252   cast_environment_->Logging()->InsertFrameEventWithDelay(
 253       now1, kAudioPlayoutDelay, rtp_timestamp1,
 254       /*frame_id*/ 0, /*delay*/ base::TimeDelta::FromMilliseconds(100));
 255
 256   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 257   base::TimeTicks now2(testing_clock_->NowTicks());
 258   cast_environment_->Logging()->InsertEncodedFrameEvent(
 259       now2, kAudioFrameEncoded, rtp_timestamp2,
 260       /*frame_id*/ 0, /*size*/ 123, /* key_frame - unused */ false,
 261       /*target_bitrate - unused*/ 0);
 262
 263   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 264   base::TimeTicks now3(testing_clock_->NowTicks());
 265   cast_environment_->Logging()->InsertFrameEvent(
 266       now3, kAudioFrameDecoded, rtp_timestamp1, /*frame_id*/ 0);
 267
 268   GetEventsAndReset();
 269
 270   ASSERT_EQ(2u, frame_events_.size());
 271
 272   RtpTimestamp relative_rtp_timestamp = rtp_timestamp1 - first_rtp_timestamp_;
 273   FrameEventList::iterator it = frame_events_.begin();
 274
 275   linked_ptr<AggregatedFrameEvent> event = *it;
 276
 277   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 278
 279   ASSERT_EQ(2, event->event_type_size());
 280   EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
 281   EXPECT_EQ(media::cast::proto::AUDIO_FRAME_DECODED, event->event_type(1));
 282
 283   ASSERT_EQ(2, event->event_timestamp_ms_size());
 284   EXPECT_EQ(InMilliseconds(now1), event->event_timestamp_ms(0));
 285   EXPECT_EQ(InMilliseconds(now3), event->event_timestamp_ms(1));
 286
 287   EXPECT_FALSE(event->has_key_frame());
 288
 289   relative_rtp_timestamp = rtp_timestamp2 - first_rtp_timestamp_;
 290   ++it;
 291
 292   event = *it;
 293
 294   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 295
 296   ASSERT_EQ(1, event->event_type_size());
 297   EXPECT_EQ(media::cast::proto::AUDIO_FRAME_ENCODED, event->event_type(0));
 298
 299   ASSERT_EQ(1, event->event_timestamp_ms_size());
 300   EXPECT_EQ(InMilliseconds(now2), event->event_timestamp_ms(0));
 301
 302   EXPECT_FALSE(event->has_key_frame());
 303 }
 304
 305 TEST_F(EncodingEventSubscriberTest, PacketEvent) {
 306   Init(AUDIO_EVENT);
 307   base::TimeTicks now(testing_clock_->NowTicks());
 308   RtpTimestamp rtp_timestamp = 100;
 309   int packet_id = 2;
 310   int size = 100;
 311   cast_environment_->Logging()->InsertPacketEvent(
 312       now, kAudioPacketReceived, rtp_timestamp, /*frame_id*/ 0, packet_id,
 313       /*max_packet_id*/ 10, size);
 314
 315   GetEventsAndReset();
 316
 317   ASSERT_EQ(1u, packet_events_.size());
 318
 319   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 320   PacketEventList::iterator it = packet_events_.begin();
 321
 322   linked_ptr<AggregatedPacketEvent> event = *it;
 323
 324   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 325
 326   ASSERT_EQ(1, event->base_packet_event_size());
 327   const BasePacketEvent& base_event = event->base_packet_event(0);
 328   EXPECT_EQ(packet_id, base_event.packet_id());
 329   ASSERT_EQ(1, base_event.event_type_size());
 330   EXPECT_EQ(media::cast::proto::AUDIO_PACKET_RECEIVED,
 331             base_event.event_type(0));
 332   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 333   EXPECT_EQ(InMilliseconds(now), base_event.event_timestamp_ms(0));
 334   EXPECT_EQ(size, base_event.size());
 335
 336   GetEventsAndReset();
 337   EXPECT_TRUE(packet_events_.empty());
 338 }
 339
 340 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) {
 341   Init(VIDEO_EVENT);
 342   base::TimeTicks now1(testing_clock_->NowTicks());
 343   RtpTimestamp rtp_timestamp = 100;
 344   int packet_id = 2;
 345   int size = 100;
 346   cast_environment_->Logging()->InsertPacketEvent(now1,
 347                                                   kVideoPacketSentToNetwork,
 348                                                   rtp_timestamp,
 349                                                   /*frame_id*/ 0,
 350                                                   packet_id,
 351                                                   /*max_packet_id*/ 10,
 352                                                   size);
 353
 354   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 355   base::TimeTicks now2(testing_clock_->NowTicks());
 356   cast_environment_->Logging()->InsertPacketEvent(now2,
 357                                                   kVideoPacketRetransmitted,
 358                                                   rtp_timestamp,
 359                                                   /*frame_id*/ 0,
 360                                                   packet_id,
 361                                                   /*max_packet_id*/ 10,
 362                                                   size);
 363
 364   GetEventsAndReset();
 365
 366   ASSERT_EQ(1u, packet_events_.size());
 367
 368   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 369   PacketEventList::iterator it = packet_events_.begin();
 370
 371   linked_ptr<AggregatedPacketEvent> event = *it;
 372
 373   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 374
 375   ASSERT_EQ(1, event->base_packet_event_size());
 376   const BasePacketEvent& base_event = event->base_packet_event(0);
 377   EXPECT_EQ(packet_id, base_event.packet_id());
 378   ASSERT_EQ(2, base_event.event_type_size());
 379   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
 380             base_event.event_type(0));
 381   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
 382             base_event.event_type(1));
 383   ASSERT_EQ(2, base_event.event_timestamp_ms_size());
 384   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 385   EXPECT_EQ(InMilliseconds(now2), base_event.event_timestamp_ms(1));
 386 }
 387
 388 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) {
 389   Init(VIDEO_EVENT);
 390   base::TimeTicks now1(testing_clock_->NowTicks());
 391   RtpTimestamp rtp_timestamp = 100;
 392   int packet_id_1 = 2;
 393   int packet_id_2 = 3;
 394   int size = 100;
 395   cast_environment_->Logging()->InsertPacketEvent(now1,
 396                                                   kVideoPacketSentToNetwork,
 397                                                   rtp_timestamp,
 398                                                   /*frame_id*/ 0,
 399                                                   packet_id_1,
 400                                                   /*max_packet_id*/ 10,
 401                                                   size);
 402
 403   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 404   base::TimeTicks now2(testing_clock_->NowTicks());
 405   cast_environment_->Logging()->InsertPacketEvent(now2,
 406                                                   kVideoPacketRetransmitted,
 407                                                   rtp_timestamp,
 408                                                   /*frame_id*/ 0,
 409                                                   packet_id_2,
 410                                                   /*max_packet_id*/ 10,
 411                                                   size);
 412
 413   GetEventsAndReset();
 414
 415   ASSERT_EQ(1u, packet_events_.size());
 416
 417   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 418   PacketEventList::iterator it = packet_events_.begin();
 419
 420   linked_ptr<AggregatedPacketEvent> event = *it;
 421
 422   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 423
 424   ASSERT_EQ(2, event->base_packet_event_size());
 425   const BasePacketEvent& base_event = event->base_packet_event(0);
 426   EXPECT_EQ(packet_id_1, base_event.packet_id());
 427   ASSERT_EQ(1, base_event.event_type_size());
 428   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
 429             base_event.event_type(0));
 430   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 431   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 432
 433   const BasePacketEvent& base_event_2 = event->base_packet_event(1);
 434   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
 435   ASSERT_EQ(1, base_event_2.event_type_size());
 436   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
 437             base_event_2.event_type(0));
 438   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
 439   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 440 }
 441
 442 TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) {
 443   Init(VIDEO_EVENT);
 444   base::TimeTicks now1(testing_clock_->NowTicks());
 445   RtpTimestamp rtp_timestamp_1 = 100;
 446   RtpTimestamp rtp_timestamp_2 = 200;
 447   int packet_id_1 = 2;
 448   int packet_id_2 = 3;
 449   int size = 100;
 450   cast_environment_->Logging()->InsertPacketEvent(now1,
 451                                                   kVideoPacketSentToNetwork,
 452                                                   rtp_timestamp_1,
 453                                                   /*frame_id*/ 0,
 454                                                   packet_id_1,
 455                                                   /*max_packet_id*/ 10,
 456                                                   size);
 457
 458   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 459   base::TimeTicks now2(testing_clock_->NowTicks());
 460   cast_environment_->Logging()->InsertPacketEvent(now2,
 461                                                   kVideoPacketRetransmitted,
 462                                                   rtp_timestamp_2,
 463                                                   /*frame_id*/ 0,
 464                                                   packet_id_2,
 465                                                   /*max_packet_id*/ 10,
 466                                                   size);
 467
 468   GetEventsAndReset();
 469
 470   ASSERT_EQ(2u, packet_events_.size());
 471
 472   RtpTimestamp relative_rtp_timestamp = rtp_timestamp_1 - first_rtp_timestamp_;
 473   PacketEventList::iterator it = packet_events_.begin();
 474
 475   linked_ptr<AggregatedPacketEvent> event = *it;
 476
 477   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 478
 479   ASSERT_EQ(1, event->base_packet_event_size());
 480   const BasePacketEvent& base_event = event->base_packet_event(0);
 481   EXPECT_EQ(packet_id_1, base_event.packet_id());
 482   ASSERT_EQ(1, base_event.event_type_size());
 483   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
 484             base_event.event_type(0));
 485   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 486   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 487
 488   relative_rtp_timestamp = rtp_timestamp_2 - first_rtp_timestamp_;
 489   ++it;
 490   ASSERT_TRUE(it != packet_events_.end());
 491
 492   event = *it;
 493   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 494
 495   ASSERT_EQ(1, event->base_packet_event_size());
 496   const BasePacketEvent& base_event_2 = event->base_packet_event(0);
 497   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
 498   ASSERT_EQ(1, base_event_2.event_type_size());
 499   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
 500             base_event_2.event_type(0));
 501   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
 502   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 503 }
 504
 505 TEST_F(EncodingEventSubscriberTest, FirstRtpTimestamp) {
 506   Init(VIDEO_EVENT);
 507   RtpTimestamp rtp_timestamp = 12345;
 508   base::TimeTicks now(testing_clock_->NowTicks());
 509
 510   cast_environment_->Logging()->InsertFrameEvent(now,
 511                                                  kVideoFrameCaptureBegin,
 512                                                  rtp_timestamp,
 513                                                  /*frame_id*/ 0);
 514
 515   cast_environment_->Logging()->InsertFrameEvent(now,
 516                                                  kVideoFrameCaptureEnd,
 517                                                  rtp_timestamp + 30,
 518                                                  /*frame_id*/ 1);
 519
 520   GetEventsAndReset();
 521
 522   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
 523   FrameEventList::iterator it = frame_events_.begin();
 524   ASSERT_NE(frame_events_.end(), it);
 525   EXPECT_EQ(0u, (*it)->relative_rtp_timestamp());
 526
 527   ++it;
 528   ASSERT_NE(frame_events_.end(), it);
 529   EXPECT_EQ(30u, (*it)->relative_rtp_timestamp());
 530
 531   rtp_timestamp = 67890;
 532
 533   cast_environment_->Logging()->InsertFrameEvent(now,
 534                                                  kVideoFrameCaptureBegin,
 535                                                  rtp_timestamp,
 536                                                  /*frame_id*/ 0);
 537   GetEventsAndReset();
 538
 539   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
 540 }
 541
 542 TEST_F(EncodingEventSubscriberTest, RelativeRtpTimestampWrapAround) {
 543   Init(VIDEO_EVENT);
 544   RtpTimestamp rtp_timestamp = 0xffffffff - 20;
 545   base::TimeTicks now(testing_clock_->NowTicks());
 546
 547   cast_environment_->Logging()->InsertFrameEvent(now,
 548                                                  kVideoFrameCaptureBegin,
 549                                                  rtp_timestamp,
 550                                                  /*frame_id*/ 0);
 551
 552   // RtpTimestamp has now wrapped around.
 553   cast_environment_->Logging()->InsertFrameEvent(now,
 554                                                  kVideoFrameCaptureEnd,
 555                                                  rtp_timestamp + 30,
 556                                                  /*frame_id*/ 1);
 557
 558   GetEventsAndReset();
 559
 560   FrameEventList::iterator it = frame_events_.begin();
 561   ASSERT_NE(frame_events_.end(), it);
 562   EXPECT_EQ(0u, (*it)->relative_rtp_timestamp());
 563
 564   ++it;
 565   ASSERT_NE(frame_events_.end(), it);
 566   EXPECT_EQ(30u, (*it)->relative_rtp_timestamp());
 567 }
 568
 569 TEST_F(EncodingEventSubscriberTest, MaxEventsPerProto) {
 570   Init(VIDEO_EVENT);
 571   RtpTimestamp rtp_timestamp = 100;
 572   for (int i = 0; i < kMaxEventsPerProto + 1; i++) {
 573     cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(),
 574                                                    kVideoAckReceived,
 575                                                    rtp_timestamp,
 576                                                    /*frame_id*/ 0);
 577     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
 578   }
 579
 580   GetEventsAndReset();
 581
 582   ASSERT_EQ(2u, frame_events_.size());
 583   FrameEventList::iterator frame_it = frame_events_.begin();
 584   ASSERT_TRUE(frame_it != frame_events_.end());
 585
 586   linked_ptr<AggregatedFrameEvent> frame_event = *frame_it;
 587
 588   EXPECT_EQ(kMaxEventsPerProto, frame_event->event_type_size());
 589
 590   for (int i = 0; i < kMaxPacketsPerFrame + 1; i++) {
 591     cast_environment_->Logging()->InsertPacketEvent(
 592         testing_clock_->NowTicks(),
 593         kVideoPacketRetransmitted,
 594         rtp_timestamp,
 595         /*frame_id*/ 0,
 596         i,
 597         kMaxPacketsPerFrame,
 598         123);
 599     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
 600   }
 601
 602   GetEventsAndReset();
 603
 604   EXPECT_EQ(2u, packet_events_.size());
 605
 606   PacketEventList::iterator packet_it = packet_events_.begin();
 607   ASSERT_TRUE(packet_it != packet_events_.end());
 608
 609   linked_ptr<AggregatedPacketEvent> packet_event = *packet_it;
 610
 611   EXPECT_EQ(kMaxPacketsPerFrame,
 612       packet_event->base_packet_event_size());
 613
 614   ++packet_it;
 615   packet_event = *packet_it;
 616   EXPECT_EQ(1, packet_event->base_packet_event_size());
 617
 618   for (int j = 0; j < kMaxEventsPerProto + 1; j++) {
 619     cast_environment_->Logging()->InsertPacketEvent(
 620         testing_clock_->NowTicks(),
 621         kVideoPacketRetransmitted,
 622         rtp_timestamp,
 623         /*frame_id*/ 0,
 624         0,
 625         0,
 626         123);
 627     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
 628   }
 629
 630   GetEventsAndReset();
 631
 632   EXPECT_EQ(2u, packet_events_.size());
 633   packet_it = packet_events_.begin();
 634   ASSERT_TRUE(packet_it != packet_events_.end());
 635
 636   packet_event = *packet_it;
 637
 638   EXPECT_EQ(kMaxEventsPerProto,
 639       packet_event->base_packet_event(0).event_type_size());
 640
 641   ++packet_it;
 642   packet_event = *packet_it;
 643   EXPECT_EQ(1, packet_event->base_packet_event(0).event_type_size());
 644 }
 645
 646 }  // namespace cast
 647 }  // namespace media