Cast: Deduplicate event types in cast library.

media/cast/audio_receiver/audio_receiver.cc

 // Copyright 2013 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/audio_receiver/audio_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/audio_receiver/audio_decoder.h"
 #include "media/cast/transport/cast_transport_defines.h"
 
 namespace {
 const int kMinSchedulingDelayMs = 1;
 // TODO(miu): This should go in AudioReceiverConfig.
 const int kTypicalAudioFrameDurationMs = 10;
 }  // namespace
 
 namespace media {
 namespace cast {
 
 AudioReceiver::AudioReceiver(scoped_refptr<CastEnvironment> cast_environment,
                              const AudioReceiverConfig& audio_config,
                              transport::PacedPacketSender* const packet_sender)
     : RtpReceiver(cast_environment->Clock(), &audio_config, NULL),
       cast_environment_(cast_environment),
-      event_subscriber_(kReceiverRtcpEventHistorySize,
-                        ReceiverRtcpEventSubscriber::kAudioEventSubscriber),
+      event_subscriber_(kReceiverRtcpEventHistorySize, AUDIO_EVENT),
       codec_(audio_config.codec),
       frequency_(audio_config.frequency),
       target_delay_delta_(
           base::TimeDelta::FromMilliseconds(audio_config.rtp_max_delay_ms)),
       framer_(cast_environment->Clock(),
               this,
               audio_config.incoming_ssrc,
               true,
               audio_config.rtp_max_delay_ms / kTypicalAudioFrameDurationMs),
       rtcp_(cast_environment,
             NULL,
             NULL,
             packet_sender,
             GetStatistics(),
             audio_config.rtcp_mode,
             base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
             audio_config.feedback_ssrc,
             audio_config.incoming_ssrc,
-            audio_config.rtcp_c_name),
+            audio_config.rtcp_c_name,
+            true),
       is_waiting_for_consecutive_frame_(false),
       weak_factory_(this) {
   if (!audio_config.use_external_decoder)
     audio_decoder_.reset(new AudioDecoder(cast_environment, audio_config));
   decryptor_.Initialize(audio_config.aes_key, audio_config.aes_iv_mask);
   rtcp_.SetTargetDelay(target_delay_delta_);
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
   memset(frame_id_to_rtp_timestamp_, 0, sizeof(frame_id_to_rtp_timestamp_));
 }
 
@@ skipping 17 matching lines @@
   // TODO(pwestin): update this as video to refresh over time.
   if (time_first_incoming_packet_.is_null()) {
     InitializeTimers();
     first_incoming_rtp_timestamp_ = rtp_header.rtp_timestamp;
     time_first_incoming_packet_ = now;
   }
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
       rtp_header.rtp_timestamp;
   cast_environment_->Logging()->InsertPacketEvent(
-      now, kAudioPacketReceived, rtp_header.rtp_timestamp,
+      now, PACKET_RECEIVED, AUDIO_EVENT, rtp_header.rtp_timestamp,
       rtp_header.frame_id, rtp_header.packet_id, rtp_header.max_packet_id,
       payload_size);
 
   bool duplicate = false;
   const bool complete =
       framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate);
-  if (duplicate) {
-    cast_environment_->Logging()->InsertPacketEvent(
-        now,
-        kDuplicateAudioPacketReceived,
-        rtp_header.rtp_timestamp,
-        rtp_header.frame_id,
-        rtp_header.packet_id,
-        rtp_header.max_packet_id,
-        payload_size);
-    // Duplicate packets are ignored.
-    return;
-  }
-  if (!complete)
+
+  // Duplicate packets are ignored.
+  if (duplicate || !complete)
     return;
 
   EmitAvailableEncodedFrames();
 }
 
 void AudioReceiver::GetRawAudioFrame(
     const AudioFrameDecodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!callback.is_null());
   DCHECK(audio_decoder_.get());
@@ skipping 31 matching lines @@
     const AudioFrameDecodedCallback& callback,
     uint32 frame_id,
     uint32 rtp_timestamp,
     const base::TimeTicks& playout_time,
     scoped_ptr<AudioBus> audio_bus,
     bool is_continuous) {
   DCHECK(cast_environment->CurrentlyOn(CastEnvironment::MAIN));
   if (audio_bus.get()) {
     const base::TimeTicks now = cast_environment->Clock()->NowTicks();
     cast_environment->Logging()->InsertFrameEvent(
-        now, kAudioFrameDecoded, rtp_timestamp, frame_id);
+        now, FRAME_DECODED, AUDIO_EVENT, rtp_timestamp, frame_id);
     cast_environment->Logging()->InsertFrameEventWithDelay(
-        now, kAudioPlayoutDelay, rtp_timestamp, frame_id,
+        now, FRAME_PLAYOUT, AUDIO_EVENT, rtp_timestamp, frame_id,
         playout_time - now);
   }
   callback.Run(audio_bus.Pass(), playout_time, is_continuous);
 }
 
 void AudioReceiver::GetEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   frame_request_queue_.push_back(callback);
   EmitAvailableEncodedFrames();
@@ skipping 88 matching lines @@
   target_delay_delta_ = target_delay;
   rtcp_.SetTargetDelay(target_delay_delta_);
 }
 
 void AudioReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_message.ack_frame_id_ & 0xff];
   cast_environment_->Logging()->InsertFrameEvent(
-      now, kAudioAckSent, rtp_timestamp, cast_message.ack_frame_id_);
+      now, FRAME_ACK_SENT, AUDIO_EVENT, rtp_timestamp,
+      cast_message.ack_frame_id_);
 
   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
   event_subscriber_.GetRtcpEventsAndReset(&rtcp_events);
   rtcp_.SendRtcpFromRtpReceiver(&cast_message, &rtcp_events);
 }
 
 base::TimeTicks AudioReceiver::GetPlayoutTime(base::TimeTicks now,
                                               uint32 rtp_timestamp) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Senders time in ms when this frame was recorded.
@@ skipping 93 matching lines @@
 }
 
 void AudioReceiver::SendNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   framer_.SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media