Cast: Deduplicate event types in cast library.

media/cast/logging/stats_event_subscriber.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 "media/cast/logging/stats_event_subscriber.h"
 
 #include "base/logging.h"
 #include "base/values.h"
 
 #define STAT_ENUM_TO_STRING(enum) \
   case enum:                      \
     return #enum
 
 namespace media {
 namespace cast {
 
 namespace {
 
 using media::cast::CastLoggingEvent;
 using media::cast::EventMediaType;
 
 const size_t kMaxFrameEventTimeMapSize = 100;
 const size_t kMaxPacketEventTimeMapSize = 1000;
 
-CastLoggingEvent GetCapturedEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ?
-      kAudioFrameCaptureBegin : kVideoFrameCaptureBegin;
-}
-
-CastLoggingEvent GetEncodedEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioFrameEncoded : kVideoFrameEncoded;
-}
-
-CastLoggingEvent GetDecodedEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioFrameDecoded : kVideoFrameDecoded;
-}
-
-CastLoggingEvent GetPlayoutEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioPlayoutDelay : kVideoRenderDelay;
-}
-
-CastLoggingEvent GetPacketSentEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioPacketSentToNetwork :
-                                     kVideoPacketSentToNetwork;
-}
-
-CastLoggingEvent GetPacketReceivedEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioPacketReceived :
-                                     kVideoPacketReceived;
-}
-
-CastLoggingEvent GetPacketRetransmittedEvent(EventMediaType media_type) {
-  return media_type == AUDIO_EVENT ? kAudioPacketRetransmitted :
-                                     kVideoPacketRetransmitted;
-}
-
 bool IsReceiverEvent(CastLoggingEvent event) {
-  return event == kAudioFrameDecoded
-      || event == kVideoFrameDecoded
-      || event == kAudioPlayoutDelay
-      || event == kVideoRenderDelay
-      || event == kAudioAckSent
-      || event == kVideoAckSent
-      || event == kAudioPacketReceived
-      || event == kVideoPacketReceived
-      || event == kDuplicateAudioPacketReceived
-      || event == kDuplicateVideoPacketReceived;
+  return event == FRAME_DECODED
+      || event == FRAME_PLAYOUT
+      || event == FRAME_ACK_SENT
+      || event == PACKET_RECEIVED;
 }
 
 }  // namespace
 
 StatsEventSubscriber::StatsEventSubscriber(
     EventMediaType event_media_type,
     base::TickClock* clock,
     ReceiverTimeOffsetEstimator* offset_estimator)
     : event_media_type_(event_media_type),
       clock_(clock),
       offset_estimator_(offset_estimator),
       network_latency_datapoints_(0),
       e2e_latency_datapoints_(0) {
   DCHECK(event_media_type == AUDIO_EVENT || event_media_type == VIDEO_EVENT);
   base::TimeTicks now = clock_->NowTicks();
   start_time_ = now;
   last_response_received_time_ = base::TimeTicks();
 }
 
 StatsEventSubscriber::~StatsEventSubscriber() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void StatsEventSubscriber::OnReceiveFrameEvent(const FrameEvent& frame_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CastLoggingEvent type = frame_event.type;
-  if (GetEventMediaType(type) != event_media_type_)
+  if (frame_event.media_type != event_media_type_)
     return;
 
   FrameStatsMap::iterator it = frame_stats_.find(type);
   if (it == frame_stats_.end()) {
     FrameLogStats stats;
     stats.event_counter = 1;
     stats.sum_size = frame_event.size;
     stats.sum_delay = frame_event.delay_delta;
     frame_stats_.insert(std::make_pair(type, stats));
   } else {
     ++(it->second.event_counter);
     it->second.sum_size += frame_event.size;
     it->second.sum_delay += frame_event.delay_delta;
   }
 
-  if (type == GetCapturedEvent(event_media_type_)) {
+  if (type == FRAME_CAPTURE_BEGIN) {
     RecordFrameCapturedTime(frame_event);
-  } else if (type == GetPlayoutEvent(event_media_type_)) {
+  } else if (type == FRAME_PLAYOUT) {
     RecordE2ELatency(frame_event);
   }
 
   if (IsReceiverEvent(type))
     UpdateLastResponseTime(frame_event.timestamp);
 }
 
 void StatsEventSubscriber::OnReceivePacketEvent(
     const PacketEvent& packet_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CastLoggingEvent type = packet_event.type;
-  if (GetEventMediaType(type) != event_media_type_)
+  if (packet_event.media_type != event_media_type_)
     return;
 
   PacketStatsMap::iterator it = packet_stats_.find(type);
   if (it == packet_stats_.end()) {
     PacketLogStats stats;
     stats.event_counter = 1;
     stats.sum_size = packet_event.size;
     packet_stats_.insert(std::make_pair(type, stats));
   } else {
     ++(it->second.event_counter);
     it->second.sum_size += packet_event.size;
   }
 
-  if (type == GetPacketSentEvent(event_media_type_) ||
-      type == GetPacketReceivedEvent(event_media_type_)) {
+  if (type == PACKET_SENT_TO_NETWORK ||
+      type == PACKET_RECEIVED) {
     RecordNetworkLatency(packet_event);
-  } else if (type == GetPacketRetransmittedEvent(event_media_type_)) {
+  } else if (type == PACKET_RETRANSMITTED) {
     // We only measure network latency using packets that doesn't have to be
     // retransmitted as there is precisely one sent-receive timestamp pairs.
     ErasePacketSentTime(packet_event);
   }
 
   if (IsReceiverEvent(type))
     UpdateLastResponseTime(packet_event.timestamp);
 }
 
 scoped_ptr<base::DictionaryValue> StatsEventSubscriber::GetStats() const {
@@ skipping 49 matching lines @@
 }
 
 void StatsEventSubscriber::GetStatsInternal(StatsMap* stats_map) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   stats_map->clear();
 
   base::TimeTicks end_time = clock_->NowTicks();
 
   PopulateFpsStat(
-      end_time, GetCapturedEvent(event_media_type_), CAPTURE_FPS, stats_map);
+      end_time, FRAME_CAPTURE_BEGIN, CAPTURE_FPS, stats_map);
   PopulateFpsStat(
-      end_time, GetEncodedEvent(event_media_type_), ENCODE_FPS, stats_map);
+      end_time, FRAME_ENCODED, ENCODE_FPS, stats_map);
   PopulateFpsStat(
-      end_time, GetDecodedEvent(event_media_type_), DECODE_FPS, stats_map);
+      end_time, FRAME_DECODED, DECODE_FPS, stats_map);
   PopulatePlayoutDelayStat(stats_map);
   PopulateFrameBitrateStat(end_time, stats_map);
   PopulatePacketBitrateStat(end_time,
-                            GetPacketSentEvent(event_media_type_),
+                            PACKET_SENT_TO_NETWORK,
                             TRANSMISSION_KBPS,
                             stats_map);
   PopulatePacketBitrateStat(end_time,
-                            GetPacketRetransmittedEvent(event_media_type_),
+                            PACKET_RETRANSMITTED,
                             RETRANSMISSION_KBPS,
                             stats_map);
   PopulatePacketLossPercentageStat(stats_map);
 
   if (network_latency_datapoints_ > 0) {
     double avg_network_latency_ms =
         total_network_latency_.InMillisecondsF() /
         network_latency_datapoints_;
     stats_map->insert(
         std::make_pair(AVG_NETWORK_LATENCY_MS, avg_network_latency_ms));
@@ skipping 81 matching lines @@
         std::make_pair(packet_event.timestamp, packet_event.type);
     packet_sent_times_.insert(std::make_pair(key, value));
     if (packet_sent_times_.size() > kMaxPacketEventTimeMapSize)
       packet_sent_times_.erase(packet_sent_times_.begin());
   } else {
     std::pair<base::TimeTicks, CastLoggingEvent> value = it->second;
     CastLoggingEvent recorded_type = value.second;
     bool match = false;
     base::TimeTicks packet_sent_time;
     base::TimeTicks packet_received_time;
-    if (recorded_type == GetPacketSentEvent(event_media_type_) &&
-        packet_event.type == GetPacketReceivedEvent(event_media_type_)) {
+    if (recorded_type == PACKET_SENT_TO_NETWORK &&
+        packet_event.type == PACKET_RECEIVED) {
       packet_sent_time = value.first;
       packet_received_time = packet_event.timestamp;
       match = true;
-    } else if (recorded_type == GetPacketReceivedEvent(event_media_type_) &&
-        packet_event.type == GetPacketSentEvent(event_media_type_)) {
+    } else if (recorded_type == PACKET_RECEIVED &&
+        packet_event.type == PACKET_SENT_TO_NETWORK) {
       packet_sent_time = packet_event.timestamp;
       packet_received_time = value.first;
       match = true;
     }
     if (match) {
       // Subtract by offset.
       packet_received_time -= receiver_offset;
 
       total_network_latency_ += packet_received_time - packet_sent_time;
       network_latency_datapoints_++;
@@ skipping 11 matching lines @@
     double fps = 0.0;
     base::TimeDelta duration = (end_time - start_time_);
     int count = it->second.event_counter;
     if (duration > base::TimeDelta())
       fps = count / duration.InSecondsF();
     stats_map->insert(std::make_pair(stat, fps));
   }
 }
 
 void StatsEventSubscriber::PopulatePlayoutDelayStat(StatsMap* stats_map) const {
-  CastLoggingEvent event = GetPlayoutEvent(event_media_type_);
-  FrameStatsMap::const_iterator it = frame_stats_.find(event);
+  FrameStatsMap::const_iterator it = frame_stats_.find(FRAME_PLAYOUT);
   if (it != frame_stats_.end()) {
     double avg_delay_ms = 0.0;
     base::TimeDelta sum_delay = it->second.sum_delay;
     int count = it->second.event_counter;
     if (count != 0)
       avg_delay_ms = sum_delay.InMillisecondsF() / count;
     stats_map->insert(std::make_pair(AVG_PLAYOUT_DELAY_MS, avg_delay_ms));
   }
 }
 
 void StatsEventSubscriber::PopulateFrameBitrateStat(base::TimeTicks end_time,
                                                     StatsMap* stats_map) const {
-  CastLoggingEvent event = GetEncodedEvent(event_media_type_);
-  FrameStatsMap::const_iterator it = frame_stats_.find(event);
+  FrameStatsMap::const_iterator it = frame_stats_.find(FRAME_ENCODED);
   if (it != frame_stats_.end()) {
     double kbps = 0.0;
     base::TimeDelta duration = end_time - start_time_;
     if (duration > base::TimeDelta()) {
       kbps = it->second.sum_size / duration.InMillisecondsF() * 8;
     }
 
     stats_map->insert(std::make_pair(ENCODE_KBPS, kbps));
   }
 }
@@ skipping 14 matching lines @@
     stats_map->insert(std::make_pair(stat, kbps));
   }
 }
 
 void StatsEventSubscriber::PopulatePacketLossPercentageStat(
     StatsMap* stats_map) const {
   // We assume that retransmission means that the packet's previous
   // (re)transmission was lost.
   // This means the percentage of packet loss is
   // (# of retransmit events) / (# of transmit + retransmit events).
-  CastLoggingEvent packet_sent_event = GetPacketSentEvent(event_media_type_);
-  CastLoggingEvent packet_retransmitted_event =
-      GetPacketRetransmittedEvent(event_media_type_);
   PacketStatsMap::const_iterator sent_it =
-      packet_stats_.find(packet_sent_event);
+      packet_stats_.find(PACKET_SENT_TO_NETWORK);
   if (sent_it == packet_stats_.end())
     return;
   PacketStatsMap::const_iterator retransmitted_it =
-      packet_stats_.find(packet_retransmitted_event);
+      packet_stats_.find(PACKET_RETRANSMITTED);
   int sent_count = sent_it->second.event_counter;
   int retransmitted_count = 0;
   if (retransmitted_it != packet_stats_.end())
     retransmitted_count = retransmitted_it->second.event_counter;
   double packet_loss_fraction = static_cast<double>(retransmitted_count) /
                                 (sent_count + retransmitted_count);
   stats_map->insert(
       std::make_pair(PACKET_LOSS_FRACTION, packet_loss_fraction));
 }
 
 StatsEventSubscriber::FrameLogStats::FrameLogStats()
     : event_counter(0), sum_size(0) {}
 StatsEventSubscriber::FrameLogStats::~FrameLogStats() {}
 
 StatsEventSubscriber::PacketLogStats::PacketLogStats()
     : event_counter(0), sum_size(0) {}
 StatsEventSubscriber::PacketLogStats::~PacketLogStats() {}
 
 }  // namespace cast
 }  // namespace media