Cast: Deduplicate event types in cast library.

media/cast/logging/encoding_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/encoding_event_subscriber.h"
 
 #include <cstring>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 44 matching lines @@
       first_rtp_timestamp_(0u) {}
 
 EncodingEventSubscriber::~EncodingEventSubscriber() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void EncodingEventSubscriber::OnReceiveFrameEvent(
     const FrameEvent& frame_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!ShouldProcessEvent(frame_event.type))
+  if (event_media_type_ != frame_event.media_type)
     return;
 
   RtpTimestamp relative_rtp_timestamp =
       GetRelativeRtpTimestamp(frame_event.rtp_timestamp);
   FrameEventMap::iterator it = frame_event_map_.find(relative_rtp_timestamp);
   linked_ptr<AggregatedFrameEvent> event_proto;
 
   // Look up existing entry. If not found, create a new entry and add to map.
   if (it == frame_event_map_.end()) {
     event_proto.reset(new AggregatedFrameEvent);
     event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
     frame_event_map_.insert(
         std::make_pair(relative_rtp_timestamp, event_proto));
   } else {
     event_proto = it->second;
     if (event_proto->event_type_size() >= kMaxEventsPerProto) {
       DVLOG(2) << "Too many events in frame " << frame_event.rtp_timestamp
                << ". Using new frame event proto.";
       AddFrameEventToStorage(event_proto);
       event_proto.reset(new AggregatedFrameEvent);
       event_proto->set_relative_rtp_timestamp(relative_rtp_timestamp);
       it->second = event_proto;
     }
   }
 
   event_proto->add_event_type(ToProtoEventType(frame_event.type));
   event_proto->add_event_timestamp_ms(
       (frame_event.timestamp - base::TimeTicks()).InMilliseconds());
 
-  if (frame_event.type == kAudioFrameEncoded) {
+  if (frame_event.type == FRAME_ENCODED) {
     event_proto->set_encoded_frame_size(frame_event.size);
-  } else if (frame_event.type == kVideoFrameEncoded) {
-    event_proto->set_encoded_frame_size(frame_event.size);
-    event_proto->set_key_frame(frame_event.key_frame);
-    event_proto->set_target_bitrate(frame_event.target_bitrate);
-  } else if (frame_event.type == kAudioPlayoutDelay ||
-             frame_event.type == kVideoRenderDelay) {
+    if (frame_event.media_type == VIDEO_EVENT) {
+      event_proto->set_encoded_frame_size(frame_event.size);
+      event_proto->set_key_frame(frame_event.key_frame);
+      event_proto->set_target_bitrate(frame_event.target_bitrate);
+    }
+  } else if (frame_event.type == FRAME_PLAYOUT) {
     event_proto->set_delay_millis(frame_event.delay_delta.InMilliseconds());
   }
 
   if (frame_event_map_.size() > kMaxMapSize)
     TransferFrameEvents(kNumMapEntriesToTransfer);
 
   DCHECK(frame_event_map_.size() <= kMaxMapSize);
   DCHECK(frame_event_storage_.size() <= max_frames_);
 }
 
 void EncodingEventSubscriber::OnReceivePacketEvent(
     const PacketEvent& packet_event) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!ShouldProcessEvent(packet_event.type))
+  if (event_media_type_ != packet_event.media_type)
     return;
   RtpTimestamp relative_rtp_timestamp =
       GetRelativeRtpTimestamp(packet_event.rtp_timestamp);
   PacketEventMap::iterator it =
       packet_event_map_.find(relative_rtp_timestamp);
   linked_ptr<AggregatedPacketEvent> event_proto;
   BasePacketEvent* base_packet_event_proto = NULL;
 
   // Look up existing entry. If not found, create a new entry and add to map.
   if (it == packet_event_map_.end()) {
@@ skipping 73 matching lines @@
   metadata->set_first_rtp_timestamp(first_rtp_timestamp_);
   metadata->set_num_frame_events(frame_event_storage_.size());
   metadata->set_num_packet_events(packet_event_storage_.size());
   metadata->set_reference_timestamp_ms_at_unix_epoch(
       (base::TimeTicks::UnixEpoch() - base::TimeTicks()).InMilliseconds());
   frame_events->swap(frame_event_storage_);
   packet_events->swap(packet_event_storage_);
   Reset();
 }
 
-bool EncodingEventSubscriber::ShouldProcessEvent(CastLoggingEvent event) {
-  return GetEventMediaType(event) == event_media_type_;
-}
-
 void EncodingEventSubscriber::TransferFrameEvents(size_t max_num_entries) {
   DCHECK(frame_event_map_.size() >= max_num_entries);
 
   FrameEventMap::iterator it = frame_event_map_.begin();
   for (size_t i = 0;
        i < max_num_entries && it != frame_event_map_.end();
        i++, ++it) {
     AddFrameEventToStorage(it->second);
   }
 
@@ skipping 48 matching lines @@
   frame_event_storage_index_ = 0;
   packet_event_map_.clear();
   packet_event_storage_.clear();
   packet_event_storage_index_ = 0;
   seen_first_rtp_timestamp_ = false;
   first_rtp_timestamp_ = 0u;
 }
 
 }  // namespace cast
 }  // namespace media