media/cast/sender: Rename deadline_utilization to encoder_utilization.

media/cast/sender/video_sender.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/sender/video_sender.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
@@ skipping 98 matching lines @@
               ? NewFixedCongestionControl(
                     (video_config.min_bitrate + video_config.max_bitrate) / 2)
               : NewAdaptiveCongestionControl(cast_environment->Clock(),
                                              video_config.max_bitrate,
                                              video_config.min_bitrate,
                                              video_config.max_frame_rate)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
       low_latency_mode_(false),
-      last_reported_deadline_utilization_(-1.0),
+      last_reported_encoder_utilization_(-1.0),
       last_reported_lossy_utilization_(-1.0),
       weak_factory_(this) {
   video_encoder_ = VideoEncoder::Create(
       cast_environment_,
       video_config,
       status_change_cb,
       create_vea_cb,
       create_video_encode_mem_cb);
   if (!video_encoder_) {
     cast_environment_->PostTask(
@@ skipping 131 matching lines @@
 
   const int bitrate = congestion_control_->GetBitrate(
       reference_time + target_playout_delay_, target_playout_delay_);
   if (bitrate != last_bitrate_) {
     video_encoder_->SetBitRate(bitrate);
     last_bitrate_ = bitrate;
   }
 
   TRACE_COUNTER_ID1("cast.stream", "Video Target Bitrate", this, bitrate);
 
-  MaybeRenderPerformanceMetricsOverlay(GetTargetPlayoutDelay(),
-                                       low_latency_mode_,
-                                       bitrate,
-                                       frames_in_encoder_ + 1,
-                                       last_reported_deadline_utilization_,
-                                       last_reported_lossy_utilization_,
-                                       video_frame.get());
+  MaybeRenderPerformanceMetricsOverlay(
+      GetTargetPlayoutDelay(), low_latency_mode_, bitrate,
+      frames_in_encoder_ + 1, last_reported_encoder_utilization_,
+      last_reported_lossy_utilization_, video_frame.get());
 
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           reference_time,
           base::Bind(&VideoSender::OnEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
                      video_frame,
                      bitrate))) {
     TRACE_EVENT_ASYNC_BEGIN1("cast.stream", "Video Encode", video_frame.get(),
                              "rtp_timestamp", rtp_timestamp.lower_32_bits());
@@ skipping 36 matching lines @@
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   // Encoding was exited with errors.
   if (!encoded_frame)
     return;
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
-  last_reported_deadline_utilization_ = encoded_frame->deadline_utilization;
+  last_reported_encoder_utilization_ = encoded_frame->encoder_utilization;
   last_reported_lossy_utilization_ = encoded_frame->lossy_utilization;
 
   TRACE_EVENT_ASYNC_END2("cast.stream", "Video Encode", video_frame.get(),
-      "deadline_utilization", last_reported_deadline_utilization_,
-      "lossy_utilization", last_reported_lossy_utilization_);
+                         "encoder_utilization",
+                         last_reported_encoder_utilization_,
+                         "lossy_utilization", last_reported_lossy_utilization_);
 
   // Report the resource utilization for processing this frame.  Take the
   // greater of the two utilization values and attenuate them such that the
   // target utilization is reported as the maximum sustainable amount.
   const double attenuated_utilization =
-      std::max(last_reported_deadline_utilization_,
+      std::max(last_reported_encoder_utilization_,
                last_reported_lossy_utilization_) /
-          (kTargetUtilizationPercentage / 100.0);
+      (kTargetUtilizationPercentage / 100.0);
   if (attenuated_utilization >= 0.0) {
     // Key frames are artificially capped to 1.0 because their actual
     // utilization is atypical compared to the other frames in the stream, and
     // this can misguide the producer of the input video frames.
     video_frame->metadata()->SetDouble(
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media