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   FrameEventMap frame_events_;
  68   PacketEventMap 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                                                    kVideoFrameCaptured,
  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_.begin()->first);
  94   EXPECT_EQ(1000u, frame_events_.rbegin()->first);
  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_.begin()->first);
 117   EXPECT_EQ(1000u, packet_events_.rbegin()->first);
 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   FrameEventMap::iterator frame_it = frame_events_.find(0);
 139   ASSERT_TRUE(frame_it != frame_events_.end());
 140
 141   linked_ptr<AggregatedFrameEvent> frame_event = frame_it->second;
 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   FrameEventMap::iterator it = frame_events_.find(relative_rtp_timestamp);
 166   ASSERT_TRUE(it != frame_events_.end());
 167
 168   linked_ptr<AggregatedFrameEvent> event = it->second;
 169
 170   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 171
 172   ASSERT_EQ(1, event->event_type_size());
 173   EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED, event->event_type(0));
 174   ASSERT_EQ(1, event->event_timestamp_ms_size());
 175   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 176
 177   EXPECT_EQ(0, event->encoded_frame_size());
 178   EXPECT_EQ(0, event->delay_millis());
 179
 180   GetEventsAndReset();
 181   EXPECT_TRUE(frame_events_.empty());
 182 }
 183
 184 TEST_F(EncodingEventSubscriberTest, FrameEventDelay) {
 185   Init(AUDIO_EVENT);
 186   base::TimeTicks now(testing_clock_->NowTicks());
 187   RtpTimestamp rtp_timestamp = 100;
 188   int delay_ms = 100;
 189   cast_environment_->Logging()->InsertFrameEventWithDelay(
 190       now, kAudioPlayoutDelay, rtp_timestamp,
 191       /*frame_id*/ 0, base::TimeDelta::FromMilliseconds(delay_ms));
 192
 193   GetEventsAndReset();
 194
 195   ASSERT_EQ(1u, frame_events_.size());
 196
 197   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 198   FrameEventMap::iterator it = frame_events_.find(relative_rtp_timestamp);
 199   ASSERT_TRUE(it != frame_events_.end());
 200
 201   linked_ptr<AggregatedFrameEvent> event = it->second;
 202
 203   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 204
 205   ASSERT_EQ(1, event->event_type_size());
 206   EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
 207   ASSERT_EQ(1, event->event_timestamp_ms_size());
 208   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 209
 210   EXPECT_EQ(0, event->encoded_frame_size());
 211   EXPECT_EQ(100, event->delay_millis());
 212 }
 213
 214 TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
 215   Init(VIDEO_EVENT);
 216   base::TimeTicks now(testing_clock_->NowTicks());
 217   RtpTimestamp rtp_timestamp = 100;
 218   int size = 123;
 219   cast_environment_->Logging()->InsertFrameEventWithSize(
 220       now, kVideoFrameEncoded, rtp_timestamp,
 221       /*frame_id*/ 0, size);
 222
 223   GetEventsAndReset();
 224
 225   ASSERT_EQ(1u, frame_events_.size());
 226
 227   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 228   FrameEventMap::iterator it = frame_events_.find(relative_rtp_timestamp);
 229   ASSERT_TRUE(it != frame_events_.end());
 230
 231   linked_ptr<AggregatedFrameEvent> event = it->second;
 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 }
 243
 244 TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
 245   Init(AUDIO_EVENT);
 246   RtpTimestamp rtp_timestamp1 = 100;
 247   RtpTimestamp rtp_timestamp2 = 200;
 248   base::TimeTicks now1(testing_clock_->NowTicks());
 249   cast_environment_->Logging()->InsertFrameEventWithDelay(
 250       now1, kAudioPlayoutDelay, rtp_timestamp1,
 251       /*frame_id*/ 0, /*delay*/ base::TimeDelta::FromMilliseconds(100));
 252
 253   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 254   base::TimeTicks now2(testing_clock_->NowTicks());
 255   cast_environment_->Logging()->InsertFrameEventWithSize(
 256       now2, kAudioFrameEncoded, rtp_timestamp2,
 257       /*frame_id*/ 0, /*size*/ 123);
 258
 259   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 260   base::TimeTicks now3(testing_clock_->NowTicks());
 261   cast_environment_->Logging()->InsertFrameEvent(
 262       now3, kAudioFrameDecoded, rtp_timestamp1, /*frame_id*/ 0);
 263
 264   GetEventsAndReset();
 265
 266   ASSERT_EQ(2u, frame_events_.size());
 267
 268   RtpTimestamp relative_rtp_timestamp = rtp_timestamp1 - first_rtp_timestamp_;
 269   FrameEventMap::iterator it = frame_events_.find(relative_rtp_timestamp);
 270   ASSERT_TRUE(it != frame_events_.end());
 271
 272   linked_ptr<AggregatedFrameEvent> event = it->second;
 273
 274   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 275
 276   ASSERT_EQ(2, event->event_type_size());
 277   EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
 278   EXPECT_EQ(media::cast::proto::AUDIO_FRAME_DECODED, event->event_type(1));
 279
 280   ASSERT_EQ(2, event->event_timestamp_ms_size());
 281   EXPECT_EQ(InMilliseconds(now1), event->event_timestamp_ms(0));
 282   EXPECT_EQ(InMilliseconds(now3), event->event_timestamp_ms(1));
 283
 284   relative_rtp_timestamp = rtp_timestamp2 - first_rtp_timestamp_;
 285   it = frame_events_.find(relative_rtp_timestamp);
 286   ASSERT_TRUE(it != frame_events_.end());
 287
 288   event = it->second;
 289
 290   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 291
 292   ASSERT_EQ(1, event->event_type_size());
 293   EXPECT_EQ(media::cast::proto::AUDIO_FRAME_ENCODED, event->event_type(0));
 294
 295   ASSERT_EQ(1, event->event_timestamp_ms_size());
 296   EXPECT_EQ(InMilliseconds(now2), event->event_timestamp_ms(0));
 297 }
 298
 299 TEST_F(EncodingEventSubscriberTest, PacketEvent) {
 300   Init(AUDIO_EVENT);
 301   base::TimeTicks now(testing_clock_->NowTicks());
 302   RtpTimestamp rtp_timestamp = 100;
 303   int packet_id = 2;
 304   int size = 100;
 305   cast_environment_->Logging()->InsertPacketEvent(
 306       now, kAudioPacketReceived, rtp_timestamp, /*frame_id*/ 0, packet_id,
 307       /*max_packet_id*/ 10, size);
 308
 309   GetEventsAndReset();
 310
 311   ASSERT_EQ(1u, packet_events_.size());
 312
 313   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 314   PacketEventMap::iterator it = packet_events_.find(relative_rtp_timestamp);
 315   ASSERT_TRUE(it != packet_events_.end());
 316
 317   linked_ptr<AggregatedPacketEvent> event = it->second;
 318
 319   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 320
 321   ASSERT_EQ(1, event->base_packet_event_size());
 322   const BasePacketEvent& base_event = event->base_packet_event(0);
 323   EXPECT_EQ(packet_id, base_event.packet_id());
 324   ASSERT_EQ(1, base_event.event_type_size());
 325   EXPECT_EQ(media::cast::proto::AUDIO_PACKET_RECEIVED,
 326             base_event.event_type(0));
 327   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 328   EXPECT_EQ(InMilliseconds(now), base_event.event_timestamp_ms(0));
 329
 330   GetEventsAndReset();
 331   EXPECT_TRUE(packet_events_.empty());
 332 }
 333
 334 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) {
 335   Init(VIDEO_EVENT);
 336   base::TimeTicks now1(testing_clock_->NowTicks());
 337   RtpTimestamp rtp_timestamp = 100;
 338   int packet_id = 2;
 339   int size = 100;
 340   cast_environment_->Logging()->InsertPacketEvent(now1,
 341                                                   kVideoPacketSentToPacer,
 342                                                   rtp_timestamp,
 343                                                   /*frame_id*/ 0,
 344                                                   packet_id,
 345                                                   /*max_packet_id*/ 10,
 346                                                   size);
 347
 348   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 349   base::TimeTicks now2(testing_clock_->NowTicks());
 350   cast_environment_->Logging()->InsertPacketEvent(now2,
 351                                                   kVideoPacketSentToNetwork,
 352                                                   rtp_timestamp,
 353                                                   /*frame_id*/ 0,
 354                                                   packet_id,
 355                                                   /*max_packet_id*/ 10,
 356                                                   size);
 357
 358   GetEventsAndReset();
 359
 360   ASSERT_EQ(1u, packet_events_.size());
 361
 362   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 363   PacketEventMap::iterator it = packet_events_.find(relative_rtp_timestamp);
 364   ASSERT_TRUE(it != packet_events_.end());
 365
 366   linked_ptr<AggregatedPacketEvent> event = it->second;
 367
 368   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 369
 370   ASSERT_EQ(1, event->base_packet_event_size());
 371   const BasePacketEvent& base_event = event->base_packet_event(0);
 372   EXPECT_EQ(packet_id, base_event.packet_id());
 373   ASSERT_EQ(2, base_event.event_type_size());
 374   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_PACER,
 375             base_event.event_type(0));
 376   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
 377             base_event.event_type(1));
 378   ASSERT_EQ(2, base_event.event_timestamp_ms_size());
 379   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 380   EXPECT_EQ(InMilliseconds(now2), base_event.event_timestamp_ms(1));
 381 }
 382
 383 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) {
 384   Init(VIDEO_EVENT);
 385   base::TimeTicks now1(testing_clock_->NowTicks());
 386   RtpTimestamp rtp_timestamp = 100;
 387   int packet_id_1 = 2;
 388   int packet_id_2 = 3;
 389   int size = 100;
 390   cast_environment_->Logging()->InsertPacketEvent(now1,
 391                                                   kVideoPacketSentToPacer,
 392                                                   rtp_timestamp,
 393                                                   /*frame_id*/ 0,
 394                                                   packet_id_1,
 395                                                   /*max_packet_id*/ 10,
 396                                                   size);
 397
 398   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 399   base::TimeTicks now2(testing_clock_->NowTicks());
 400   cast_environment_->Logging()->InsertPacketEvent(now2,
 401                                                   kVideoPacketRetransmitted,
 402                                                   rtp_timestamp,
 403                                                   /*frame_id*/ 0,
 404                                                   packet_id_2,
 405                                                   /*max_packet_id*/ 10,
 406                                                   size);
 407
 408   GetEventsAndReset();
 409
 410   ASSERT_EQ(1u, packet_events_.size());
 411
 412   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
 413   PacketEventMap::iterator it = packet_events_.find(relative_rtp_timestamp);
 414   ASSERT_TRUE(it != packet_events_.end());
 415
 416   linked_ptr<AggregatedPacketEvent> event = it->second;
 417
 418   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 419
 420   ASSERT_EQ(2, event->base_packet_event_size());
 421   const BasePacketEvent& base_event = event->base_packet_event(0);
 422   EXPECT_EQ(packet_id_1, base_event.packet_id());
 423   ASSERT_EQ(1, base_event.event_type_size());
 424   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_PACER,
 425             base_event.event_type(0));
 426   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 427   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 428
 429   const BasePacketEvent& base_event_2 = event->base_packet_event(1);
 430   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
 431   ASSERT_EQ(1, base_event_2.event_type_size());
 432   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
 433             base_event_2.event_type(0));
 434   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
 435   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 436 }
 437
 438 TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) {
 439   Init(VIDEO_EVENT);
 440   base::TimeTicks now1(testing_clock_->NowTicks());
 441   RtpTimestamp rtp_timestamp_1 = 100;
 442   RtpTimestamp rtp_timestamp_2 = 200;
 443   int packet_id_1 = 2;
 444   int packet_id_2 = 3;
 445   int size = 100;
 446   cast_environment_->Logging()->InsertPacketEvent(now1,
 447                                                   kVideoPacketSentToPacer,
 448                                                   rtp_timestamp_1,
 449                                                   /*frame_id*/ 0,
 450                                                   packet_id_1,
 451                                                   /*max_packet_id*/ 10,
 452                                                   size);
 453
 454   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
 455   base::TimeTicks now2(testing_clock_->NowTicks());
 456   cast_environment_->Logging()->InsertPacketEvent(now2,
 457                                                   kVideoPacketRetransmitted,
 458                                                   rtp_timestamp_2,
 459                                                   /*frame_id*/ 0,
 460                                                   packet_id_2,
 461                                                   /*max_packet_id*/ 10,
 462                                                   size);
 463
 464   GetEventsAndReset();
 465
 466   ASSERT_EQ(2u, packet_events_.size());
 467
 468   RtpTimestamp relative_rtp_timestamp = rtp_timestamp_1 - first_rtp_timestamp_;
 469   PacketEventMap::iterator it = packet_events_.find(relative_rtp_timestamp);
 470   ASSERT_TRUE(it != packet_events_.end());
 471
 472   linked_ptr<AggregatedPacketEvent> event = it->second;
 473
 474   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 475
 476   ASSERT_EQ(1, event->base_packet_event_size());
 477   const BasePacketEvent& base_event = event->base_packet_event(0);
 478   EXPECT_EQ(packet_id_1, base_event.packet_id());
 479   ASSERT_EQ(1, base_event.event_type_size());
 480   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_PACER,
 481             base_event.event_type(0));
 482   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
 483   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 484
 485   relative_rtp_timestamp = rtp_timestamp_2 - first_rtp_timestamp_;
 486   it = packet_events_.find(relative_rtp_timestamp);
 487   ASSERT_TRUE(it != packet_events_.end());
 488
 489   event = it->second;
 490
 491   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 492
 493   ASSERT_EQ(1, event->base_packet_event_size());
 494   const BasePacketEvent& base_event_2 = event->base_packet_event(0);
 495   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
 496   ASSERT_EQ(1, base_event_2.event_type_size());
 497   EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
 498             base_event_2.event_type(0));
 499   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
 500   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 501 }
 502
 503 TEST_F(EncodingEventSubscriberTest, FirstRtpTimestamp) {
 504   Init(VIDEO_EVENT);
 505   RtpTimestamp rtp_timestamp = 12345;
 506   base::TimeTicks now(testing_clock_->NowTicks());
 507
 508   cast_environment_->Logging()->InsertFrameEvent(now,
 509                                                  kVideoFrameCaptured,
 510                                                  rtp_timestamp,
 511                                                  /*frame_id*/ 0);
 512
 513   cast_environment_->Logging()->InsertFrameEvent(now,
 514                                                  kVideoFrameReceived,
 515                                                  rtp_timestamp + 30,
 516                                                  /*frame_id*/ 1);
 517
 518   GetEventsAndReset();
 519
 520   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
 521   FrameEventMap::iterator it = frame_events_.find(0);
 522   ASSERT_NE(frame_events_.end(), it);
 523
 524   it = frame_events_.find(30);
 525   ASSERT_NE(frame_events_.end(), it);
 526
 527   rtp_timestamp = 67890;
 528
 529   cast_environment_->Logging()->InsertFrameEvent(now,
 530                                                  kVideoFrameCaptured,
 531                                                  rtp_timestamp,
 532                                                  /*frame_id*/ 0);
 533   GetEventsAndReset();
 534
 535   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
 536 }
 537
 538 TEST_F(EncodingEventSubscriberTest, RelativeRtpTimestampWrapAround) {
 539   Init(VIDEO_EVENT);
 540   RtpTimestamp rtp_timestamp = 0xffffffff - 20;
 541   base::TimeTicks now(testing_clock_->NowTicks());
 542
 543   cast_environment_->Logging()->InsertFrameEvent(now,
 544                                                  kVideoFrameCaptured,
 545                                                  rtp_timestamp,
 546                                                  /*frame_id*/ 0);
 547
 548   // RtpTimestamp has now wrapped around.
 549   cast_environment_->Logging()->InsertFrameEvent(now,
 550                                                  kVideoFrameReceived,
 551                                                  rtp_timestamp + 30,
 552                                                  /*frame_id*/ 1);
 553
 554   GetEventsAndReset();
 555
 556   FrameEventMap::iterator it = frame_events_.find(0);
 557   ASSERT_NE(frame_events_.end(), it);
 558
 559   it = frame_events_.find(30);
 560   ASSERT_NE(frame_events_.end(), it);
 561 }
 562
 563 }  // namespace cast
 564 }  // namespace media