Cast: Deduplicate event types in cast library.

media/cast/video_sender/video_sender.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/video_sender/video_sender.h"
 
 #include <cstring>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 88 matching lines @@
   rtcp_.reset(
       new Rtcp(cast_environment_,
                rtcp_feedback_.get(),
                transport_sender_,
                NULL,  // paced sender.
                NULL,
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
                video_config.rtp_config.ssrc,
                video_config.incoming_feedback_ssrc,
-               video_config.rtcp_c_name));
+               video_config.rtcp_c_name,
+               false));
   rtcp_->SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
 
   // TODO(pwestin): pass cast_initialization_cb to |video_encoder_|
   // and remove this call.
   cast_environment_->PostTask(
       CastEnvironment::MAIN,
       FROM_HERE,
       base::Bind(cast_initialization_cb, STATUS_VIDEO_INITIALIZED));
   cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber_);
 
@@ skipping 17 matching lines @@
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(video_encoder_.get()) << "Invalid state";
 
   RtpTimestamp rtp_timestamp = GetVideoRtpTimestamp(capture_time);
   cast_environment_->Logging()->InsertFrameEvent(
-      capture_time, kVideoFrameCaptureBegin, rtp_timestamp, kFrameIdUnknown);
+      capture_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT,
+      rtp_timestamp, kFrameIdUnknown);
   cast_environment_->Logging()->InsertFrameEvent(
       cast_environment_->Clock()->NowTicks(),
-      kVideoFrameCaptureEnd,
+      FRAME_CAPTURE_END, VIDEO_EVENT,
       rtp_timestamp,
       kFrameIdUnknown);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", capture_time.ToInternalValue(),
       "rtp_timestamp", GetVideoRtpTimestamp(capture_time));
 
@@ skipping 14 matching lines @@
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   if (encoded_frame->key_frame) {
     VLOG(1) << "Send encoded key frame; frame_id:"
             << static_cast<int>(encoded_frame->frame_id);
   }
 
   DCHECK_GT(frames_in_encoder_, 0);
   frames_in_encoder_--;
   uint32 frame_id = encoded_frame->frame_id;
   cast_environment_->Logging()->InsertEncodedFrameEvent(
-      last_send_time_, kVideoFrameEncoded, encoded_frame->rtp_timestamp,
+      last_send_time_, FRAME_ENCODED, VIDEO_EVENT, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
       encoded_frame->key_frame, current_requested_bitrate_);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT1(
       "cast_perf_test", "VideoFrameEncoded",
       TRACE_EVENT_SCOPE_THREAD,
       "rtp_timestamp", GetVideoRtpTimestamp(capture_time));
 
   // Only use lowest 8 bits as key.
@@ skipping 35 matching lines @@
 void VideoSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   transport::RtcpSenderLogMessage sender_log_message;
   RtcpEventMap rtcp_events;
   event_subscriber_.GetRtcpEventsAndReset(&rtcp_events);
 
   for (RtcpEventMap::iterator it = rtcp_events.begin(); it != rtcp_events.end();
        ++it) {
     CastLoggingEvent event_type = it->second.type;
-    if (event_type == kVideoFrameCaptureBegin ||
-        event_type == kVideoFrameSentToEncoder ||
-        event_type == kVideoFrameEncoded) {
+    if (event_type == FRAME_CAPTURE_BEGIN ||
+        event_type == FRAME_ENCODED) {
       transport::RtcpSenderFrameLogMessage frame_message;
       frame_message.rtp_timestamp = it->first;
       switch (event_type) {
-        case kVideoFrameCaptureBegin:
+        case FRAME_CAPTURE_BEGIN:
           frame_message.frame_status =
               transport::kRtcpSenderFrameStatusDroppedByFlowControl;
           break;
-        case kVideoFrameSentToEncoder:
-          frame_message.frame_status =
-              transport::kRtcpSenderFrameStatusDroppedByEncoder;
-          break;
-        case kVideoFrameEncoded:
+        case FRAME_ENCODED:
           frame_message.frame_status =
               transport::kRtcpSenderFrameStatusSentToNetwork;
           break;
         default:
           NOTREACHED();
           break;
       }
       sender_log_message.push_back(frame_message);
     } else {
       // This shouldn't happen because RtcpEventMap isn't supposed to contain
@@ skipping 160 matching lines @@
   // after establishing that the receiver is active.
   if (last_acked_frame_id_ == -1) {
     ScheduleNextRtcpReport();
   }
   last_acked_frame_id_ = static_cast<int>(acked_frame_id);
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[acked_frame_id & 0xff];
   cast_environment_->Logging()->InsertFrameEvent(
-      now, kVideoAckReceived, rtp_timestamp, acked_frame_id);
+      now, FRAME_ACK_RECEIVED, VIDEO_EVENT, rtp_timestamp, acked_frame_id);
 
   VLOG(2) << "ReceivedAck:" << static_cast<int>(acked_frame_id);
   active_session_ = true;
   DCHECK_NE(-1, last_acked_frame_id_);
   UpdateFramesInFlight();
 }
 
 void VideoSender::UpdateFramesInFlight() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (last_sent_frame_id_ != -1) {
@@ skipping 24 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   transport_sender_->ResendPackets(false, missing_frames_and_packets);
 }
 
 }  // namespace cast
 }  // namespace media