Cast: Deduplicate event types in cast library.

media/cast/logging/encoding_event_subscriber_unittest.cc

 // Copyright 2014 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/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/logging/encoding_event_subscriber.h"
@@ skipping 60 matching lines @@
 };
 
 TEST_F(EncodingEventSubscriberTest, FrameEventTruncating) {
   Init(VIDEO_EVENT);
 
   base::TimeTicks now(testing_clock_->NowTicks());
 
   // Entry with RTP timestamp 0 should get dropped.
   for (int i = 0; i < 11; i++) {
     cast_environment_->Logging()->InsertFrameEvent(now,
-                                                   kVideoFrameCaptureBegin,
+                                                   FRAME_CAPTURE_BEGIN,
+                                                   VIDEO_EVENT,
                                                    i * 100,
                                                    /*frame_id*/ 0);
     cast_environment_->Logging()->InsertFrameEvent(now,
-                                                   kVideoFrameDecoded,
+                                                   FRAME_DECODED,
+                                                   VIDEO_EVENT,
                                                    i * 100,
                                                    /*frame_id*/ 0);
   }
 
   GetEventsAndReset();
 
   ASSERT_EQ(10u, frame_events_.size());
   EXPECT_EQ(100u, frame_events_.front()->relative_rtp_timestamp());
   EXPECT_EQ(1000u, frame_events_.back()->relative_rtp_timestamp());
 }
 
 TEST_F(EncodingEventSubscriberTest, PacketEventTruncating) {
   Init(AUDIO_EVENT);
 
   base::TimeTicks now(testing_clock_->NowTicks());
 
   // Entry with RTP timestamp 0 should get dropped.
   for (int i = 0; i < 11; i++) {
     cast_environment_->Logging()->InsertPacketEvent(now,
-                                                    kAudioPacketReceived,
+                                                    PACKET_RECEIVED,
+                                                    AUDIO_EVENT,
                                                     /*rtp_timestamp*/ i * 100,
                                                     /*frame_id*/ 0,
                                                     /*packet_id*/ i,
                                                     /*max_packet_id*/ 10,
                                                     /*size*/ 123);
   }
 
   GetEventsAndReset();
 
   ASSERT_EQ(10u, packet_events_.size());
   EXPECT_EQ(100u, packet_events_.front()->relative_rtp_timestamp());
   EXPECT_EQ(1000u, packet_events_.back()->relative_rtp_timestamp());
 }
 
 TEST_F(EncodingEventSubscriberTest, EventFiltering) {
   Init(VIDEO_EVENT);
 
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameDecoded,
+                                                 FRAME_DECODED,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
 
   // This is an AUDIO_EVENT and shouldn't be processed by the subscriber.
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kAudioFrameDecoded,
+                                                 FRAME_DECODED,
+                                                 AUDIO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, frame_events_.size());
   FrameEventList::iterator it = frame_events_.begin();
 
   linked_ptr<AggregatedFrameEvent> frame_event = *it;
 
   ASSERT_EQ(1, frame_event->event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED,
+  EXPECT_EQ(media::cast::proto::FRAME_DECODED,
             frame_event->event_type(0));
 
   GetEventsAndReset();
 
   EXPECT_TRUE(packet_events_.empty());
 }
 
 TEST_F(EncodingEventSubscriberTest, FrameEvent) {
   Init(VIDEO_EVENT);
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
-  cast_environment_->Logging()->InsertFrameEvent(now, kVideoFrameDecoded,
+  cast_environment_->Logging()->InsertFrameEvent(now, FRAME_DECODED,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, frame_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   FrameEventList::iterator it = frame_events_.begin();
 
   linked_ptr<AggregatedFrameEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_FRAME_DECODED, event->event_type(0));
+  EXPECT_EQ(media::cast::proto::FRAME_DECODED, event->event_type(0));
   ASSERT_EQ(1, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 
   EXPECT_EQ(0, event->encoded_frame_size());
   EXPECT_EQ(0, event->delay_millis());
 
   GetEventsAndReset();
   EXPECT_TRUE(frame_events_.empty());
 }
 
 TEST_F(EncodingEventSubscriberTest, FrameEventDelay) {
   Init(AUDIO_EVENT);
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int delay_ms = 100;
   cast_environment_->Logging()->InsertFrameEventWithDelay(
-      now, kAudioPlayoutDelay, rtp_timestamp,
+      now, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp,
       /*frame_id*/ 0, base::TimeDelta::FromMilliseconds(delay_ms));
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, frame_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   FrameEventList::iterator it = frame_events_.begin();
 
   linked_ptr<AggregatedFrameEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->event_type_size());
-  EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
+  EXPECT_EQ(media::cast::proto::FRAME_PLAYOUT, event->event_type(0));
   ASSERT_EQ(1, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 
   EXPECT_EQ(0, event->encoded_frame_size());
   EXPECT_EQ(100, event->delay_millis());
   EXPECT_FALSE(event->has_key_frame());
 }
 
 TEST_F(EncodingEventSubscriberTest, FrameEventSize) {
   Init(VIDEO_EVENT);
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int size = 123;
   bool key_frame = true;
   int target_bitrate = 1024;
   cast_environment_->Logging()->InsertEncodedFrameEvent(
-      now, kVideoFrameEncoded, rtp_timestamp,
+      now, FRAME_ENCODED, VIDEO_EVENT, rtp_timestamp,
       /*frame_id*/ 0, size, key_frame, target_bitrate);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, frame_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   FrameEventList::iterator it = frame_events_.begin();
 
   linked_ptr<AggregatedFrameEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_FRAME_ENCODED, event->event_type(0));
+  EXPECT_EQ(media::cast::proto::FRAME_ENCODED, event->event_type(0));
   ASSERT_EQ(1, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now), event->event_timestamp_ms(0));
 
   EXPECT_EQ(size, event->encoded_frame_size());
   EXPECT_EQ(0, event->delay_millis());
   EXPECT_TRUE(event->has_key_frame());
   EXPECT_EQ(key_frame, event->key_frame());
   EXPECT_EQ(target_bitrate, event->target_bitrate());
 }
 
 TEST_F(EncodingEventSubscriberTest, MultipleFrameEvents) {
   Init(AUDIO_EVENT);
   RtpTimestamp rtp_timestamp1 = 100;
   RtpTimestamp rtp_timestamp2 = 200;
   base::TimeTicks now1(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertFrameEventWithDelay(
-      now1, kAudioPlayoutDelay, rtp_timestamp1,
+      now1, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp1,
       /*frame_id*/ 0, /*delay*/ base::TimeDelta::FromMilliseconds(100));
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now2(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertEncodedFrameEvent(
-      now2, kAudioFrameEncoded, rtp_timestamp2,
+      now2, FRAME_ENCODED, AUDIO_EVENT, rtp_timestamp2,
       /*frame_id*/ 0, /*size*/ 123, /* key_frame - unused */ false,
       /*target_bitrate - unused*/ 0);
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now3(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertFrameEvent(
-      now3, kAudioFrameDecoded, rtp_timestamp1, /*frame_id*/ 0);
+      now3, FRAME_DECODED, AUDIO_EVENT, rtp_timestamp1, /*frame_id*/ 0);
 
   GetEventsAndReset();
 
   ASSERT_EQ(2u, frame_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp1 - first_rtp_timestamp_;
   FrameEventList::iterator it = frame_events_.begin();
 
   linked_ptr<AggregatedFrameEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(2, event->event_type_size());
-  EXPECT_EQ(media::cast::proto::AUDIO_PLAYOUT_DELAY, event->event_type(0));
-  EXPECT_EQ(media::cast::proto::AUDIO_FRAME_DECODED, event->event_type(1));
+  EXPECT_EQ(media::cast::proto::FRAME_PLAYOUT, event->event_type(0));
+  EXPECT_EQ(media::cast::proto::FRAME_DECODED, event->event_type(1));
 
   ASSERT_EQ(2, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now1), event->event_timestamp_ms(0));
   EXPECT_EQ(InMilliseconds(now3), event->event_timestamp_ms(1));
 
   EXPECT_FALSE(event->has_key_frame());
 
   relative_rtp_timestamp = rtp_timestamp2 - first_rtp_timestamp_;
   ++it;
 
   event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->event_type_size());
-  EXPECT_EQ(media::cast::proto::AUDIO_FRAME_ENCODED, event->event_type(0));
+  EXPECT_EQ(media::cast::proto::FRAME_ENCODED, event->event_type(0));
 
   ASSERT_EQ(1, event->event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now2), event->event_timestamp_ms(0));
 
   EXPECT_FALSE(event->has_key_frame());
 }
 
 TEST_F(EncodingEventSubscriberTest, PacketEvent) {
   Init(AUDIO_EVENT);
   base::TimeTicks now(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int packet_id = 2;
   int size = 100;
   cast_environment_->Logging()->InsertPacketEvent(
-      now, kAudioPacketReceived, rtp_timestamp, /*frame_id*/ 0, packet_id,
+      now, PACKET_RECEIVED, AUDIO_EVENT,
+      rtp_timestamp, /*frame_id*/ 0, packet_id,
       /*max_packet_id*/ 10, size);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, packet_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   PacketEventList::iterator it = packet_events_.begin();
 
   linked_ptr<AggregatedPacketEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->base_packet_event_size());
   const BasePacketEvent& base_event = event->base_packet_event(0);
   EXPECT_EQ(packet_id, base_event.packet_id());
   ASSERT_EQ(1, base_event.event_type_size());
-  EXPECT_EQ(media::cast::proto::AUDIO_PACKET_RECEIVED,
+  EXPECT_EQ(media::cast::proto::PACKET_RECEIVED,
             base_event.event_type(0));
   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now), base_event.event_timestamp_ms(0));
   EXPECT_EQ(size, base_event.size());
 
   GetEventsAndReset();
   EXPECT_TRUE(packet_events_.empty());
 }
 
 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForPacket) {
   Init(VIDEO_EVENT);
   base::TimeTicks now1(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int packet_id = 2;
   int size = 100;
   cast_environment_->Logging()->InsertPacketEvent(now1,
-                                                  kVideoPacketSentToNetwork,
+                                                  PACKET_SENT_TO_NETWORK,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp,
                                                   /*frame_id*/ 0,
                                                   packet_id,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now2(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertPacketEvent(now2,
-                                                  kVideoPacketRetransmitted,
+                                                  PACKET_RETRANSMITTED,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp,
                                                   /*frame_id*/ 0,
                                                   packet_id,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, packet_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   PacketEventList::iterator it = packet_events_.begin();
 
   linked_ptr<AggregatedPacketEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->base_packet_event_size());
   const BasePacketEvent& base_event = event->base_packet_event(0);
   EXPECT_EQ(packet_id, base_event.packet_id());
   ASSERT_EQ(2, base_event.event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
+  EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK,
             base_event.event_type(0));
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
+  EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED,
             base_event.event_type(1));
   ASSERT_EQ(2, base_event.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
   EXPECT_EQ(InMilliseconds(now2), base_event.event_timestamp_ms(1));
 }
 
 TEST_F(EncodingEventSubscriberTest, MultiplePacketEventsForFrame) {
   Init(VIDEO_EVENT);
   base::TimeTicks now1(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp = 100;
   int packet_id_1 = 2;
   int packet_id_2 = 3;
   int size = 100;
   cast_environment_->Logging()->InsertPacketEvent(now1,
-                                                  kVideoPacketSentToNetwork,
+                                                  PACKET_SENT_TO_NETWORK,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp,
                                                   /*frame_id*/ 0,
                                                   packet_id_1,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now2(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertPacketEvent(now2,
-                                                  kVideoPacketRetransmitted,
+                                                  PACKET_RETRANSMITTED,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp,
                                                   /*frame_id*/ 0,
                                                   packet_id_2,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   GetEventsAndReset();
 
   ASSERT_EQ(1u, packet_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp - first_rtp_timestamp_;
   PacketEventList::iterator it = packet_events_.begin();
 
   linked_ptr<AggregatedPacketEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(2, event->base_packet_event_size());
   const BasePacketEvent& base_event = event->base_packet_event(0);
   EXPECT_EQ(packet_id_1, base_event.packet_id());
   ASSERT_EQ(1, base_event.event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
+  EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK,
             base_event.event_type(0));
   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 
   const BasePacketEvent& base_event_2 = event->base_packet_event(1);
   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
   ASSERT_EQ(1, base_event_2.event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
+  EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED,
             base_event_2.event_type(0));
   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 }
 
 TEST_F(EncodingEventSubscriberTest, MultiplePacketEvents) {
   Init(VIDEO_EVENT);
   base::TimeTicks now1(testing_clock_->NowTicks());
   RtpTimestamp rtp_timestamp_1 = 100;
   RtpTimestamp rtp_timestamp_2 = 200;
   int packet_id_1 = 2;
   int packet_id_2 = 3;
   int size = 100;
   cast_environment_->Logging()->InsertPacketEvent(now1,
-                                                  kVideoPacketSentToNetwork,
+                                                  PACKET_SENT_TO_NETWORK,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp_1,
                                                   /*frame_id*/ 0,
                                                   packet_id_1,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   testing_clock_->Advance(base::TimeDelta::FromMilliseconds(20));
   base::TimeTicks now2(testing_clock_->NowTicks());
   cast_environment_->Logging()->InsertPacketEvent(now2,
-                                                  kVideoPacketRetransmitted,
+                                                  PACKET_RETRANSMITTED,
+                                                  VIDEO_EVENT,
                                                   rtp_timestamp_2,
                                                   /*frame_id*/ 0,
                                                   packet_id_2,
                                                   /*max_packet_id*/ 10,
                                                   size);
 
   GetEventsAndReset();
 
   ASSERT_EQ(2u, packet_events_.size());
 
   RtpTimestamp relative_rtp_timestamp = rtp_timestamp_1 - first_rtp_timestamp_;
   PacketEventList::iterator it = packet_events_.begin();
 
   linked_ptr<AggregatedPacketEvent> event = *it;
 
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->base_packet_event_size());
   const BasePacketEvent& base_event = event->base_packet_event(0);
   EXPECT_EQ(packet_id_1, base_event.packet_id());
   ASSERT_EQ(1, base_event.event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_SENT_TO_NETWORK,
+  EXPECT_EQ(media::cast::proto::PACKET_SENT_TO_NETWORK,
             base_event.event_type(0));
   ASSERT_EQ(1, base_event.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now1), base_event.event_timestamp_ms(0));
 
   relative_rtp_timestamp = rtp_timestamp_2 - first_rtp_timestamp_;
   ++it;
   ASSERT_TRUE(it != packet_events_.end());
 
   event = *it;
   EXPECT_EQ(relative_rtp_timestamp, event->relative_rtp_timestamp());
 
   ASSERT_EQ(1, event->base_packet_event_size());
   const BasePacketEvent& base_event_2 = event->base_packet_event(0);
   EXPECT_EQ(packet_id_2, base_event_2.packet_id());
   ASSERT_EQ(1, base_event_2.event_type_size());
-  EXPECT_EQ(media::cast::proto::VIDEO_PACKET_RETRANSMITTED,
+  EXPECT_EQ(media::cast::proto::PACKET_RETRANSMITTED,
             base_event_2.event_type(0));
   ASSERT_EQ(1, base_event_2.event_timestamp_ms_size());
   EXPECT_EQ(InMilliseconds(now2), base_event_2.event_timestamp_ms(0));
 }
 
 TEST_F(EncodingEventSubscriberTest, FirstRtpTimestamp) {
   Init(VIDEO_EVENT);
   RtpTimestamp rtp_timestamp = 12345;
   base::TimeTicks now(testing_clock_->NowTicks());
 
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameCaptureBegin,
+                                                 FRAME_CAPTURE_BEGIN,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
 
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameCaptureEnd,
+                                                 FRAME_CAPTURE_END,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp + 30,
                                                  /*frame_id*/ 1);
 
   GetEventsAndReset();
 
   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
   FrameEventList::iterator it = frame_events_.begin();
   ASSERT_NE(frame_events_.end(), it);
   EXPECT_EQ(0u, (*it)->relative_rtp_timestamp());
 
   ++it;
   ASSERT_NE(frame_events_.end(), it);
   EXPECT_EQ(30u, (*it)->relative_rtp_timestamp());
 
   rtp_timestamp = 67890;
 
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameCaptureBegin,
+                                                 FRAME_CAPTURE_BEGIN,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
   GetEventsAndReset();
 
   EXPECT_EQ(rtp_timestamp, first_rtp_timestamp_);
 }
 
 TEST_F(EncodingEventSubscriberTest, RelativeRtpTimestampWrapAround) {
   Init(VIDEO_EVENT);
   RtpTimestamp rtp_timestamp = 0xffffffff - 20;
   base::TimeTicks now(testing_clock_->NowTicks());
 
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameCaptureBegin,
+                                                 FRAME_CAPTURE_BEGIN,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp,
                                                  /*frame_id*/ 0);
 
   // RtpTimestamp has now wrapped around.
   cast_environment_->Logging()->InsertFrameEvent(now,
-                                                 kVideoFrameCaptureEnd,
+                                                 FRAME_CAPTURE_END,
+                                                 VIDEO_EVENT,
                                                  rtp_timestamp + 30,
                                                  /*frame_id*/ 1);
 
   GetEventsAndReset();
 
   FrameEventList::iterator it = frame_events_.begin();
   ASSERT_NE(frame_events_.end(), it);
   EXPECT_EQ(0u, (*it)->relative_rtp_timestamp());
 
   ++it;
   ASSERT_NE(frame_events_.end(), it);
   EXPECT_EQ(30u, (*it)->relative_rtp_timestamp());
 }
 
 TEST_F(EncodingEventSubscriberTest, MaxEventsPerProto) {
   Init(VIDEO_EVENT);
   RtpTimestamp rtp_timestamp = 100;
   for (int i = 0; i < kMaxEventsPerProto + 1; i++) {
     cast_environment_->Logging()->InsertFrameEvent(testing_clock_->NowTicks(),
-                                                   kVideoAckReceived,
+                                                   FRAME_ACK_RECEIVED,
+                                                   VIDEO_EVENT,
                                                    rtp_timestamp,
                                                    /*frame_id*/ 0);
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
   }
 
   GetEventsAndReset();
 
   ASSERT_EQ(2u, frame_events_.size());
   FrameEventList::iterator frame_it = frame_events_.begin();
   ASSERT_TRUE(frame_it != frame_events_.end());
 
   linked_ptr<AggregatedFrameEvent> frame_event = *frame_it;
 
   EXPECT_EQ(kMaxEventsPerProto, frame_event->event_type_size());
 
   for (int i = 0; i < kMaxPacketsPerFrame + 1; i++) {
     cast_environment_->Logging()->InsertPacketEvent(
         testing_clock_->NowTicks(),
-        kVideoPacketRetransmitted,
+        PACKET_SENT_TO_NETWORK,
+        VIDEO_EVENT,
         rtp_timestamp,
         /*frame_id*/ 0,
         i,
         kMaxPacketsPerFrame,
         123);
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
   }
 
   GetEventsAndReset();
 
   EXPECT_EQ(2u, packet_events_.size());
 
   PacketEventList::iterator packet_it = packet_events_.begin();
   ASSERT_TRUE(packet_it != packet_events_.end());
 
   linked_ptr<AggregatedPacketEvent> packet_event = *packet_it;
 
   EXPECT_EQ(kMaxPacketsPerFrame,
       packet_event->base_packet_event_size());
 
   ++packet_it;
   packet_event = *packet_it;
   EXPECT_EQ(1, packet_event->base_packet_event_size());
 
   for (int j = 0; j < kMaxEventsPerProto + 1; j++) {
     cast_environment_->Logging()->InsertPacketEvent(
         testing_clock_->NowTicks(),
-        kVideoPacketRetransmitted,
+        PACKET_SENT_TO_NETWORK,
+        VIDEO_EVENT,
         rtp_timestamp,
         /*frame_id*/ 0,
         0,
         0,
         123);
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(30));
   }
 
   GetEventsAndReset();
 
   EXPECT_EQ(2u, packet_events_.size());
   packet_it = packet_events_.begin();
   ASSERT_TRUE(packet_it != packet_events_.end());
 
   packet_event = *packet_it;
 
   EXPECT_EQ(kMaxEventsPerProto,
       packet_event->base_packet_event(0).event_type_size());
 
   ++packet_it;
   packet_event = *packet_it;
   EXPECT_EQ(1, packet_event->base_packet_event(0).event_type_size());
 }
 
 }  // namespace cast
 }  // namespace media