media/cast/sender: Rename deadline_utilization to encoder_utilization.

media/cast/sender/external_video_encoder.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/external_video_encoder.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 42 matching lines @@
   // The reference time for this frame.
   const base::TimeTicks reference_time;
 
   // The callback to run when the result is ready.
   const VideoEncoder::FrameEncodedCallback frame_encoded_callback;
 
   // The target encode bit rate.
   const int target_bit_rate;
 
   // The real-world encode start time.  This is used to compute the encoded
-  // frame's |deadline_utilization| and so it uses the real-world clock instead
+  // frame's |encoder_utilization| and so it uses the real-world clock instead
   // of the CastEnvironment clock, the latter of which might be simulated.
   const base::TimeTicks start_time;
 
   InProgressFrameEncode(const scoped_refptr<VideoFrame>& v_frame,
                         base::TimeTicks r_time,
                         VideoEncoder::FrameEncodedCallback callback,
                         int bit_rate)
       : video_frame(v_frame),
         reference_time(r_time),
         frame_encoded_callback(callback),
@@ skipping 226 matching lines @@
       }
       encoded_frame->data.append(
           static_cast<const char*>(output_buffer->memory()), payload_size);
 
       // If FRAME_DURATION metadata was provided in the source VideoFrame,
       // compute the utilization metrics.
       base::TimeDelta frame_duration;
       if (request.video_frame->metadata()->GetTimeDelta(
               media::VideoFrameMetadata::FRAME_DURATION, &frame_duration) &&
           frame_duration > base::TimeDelta()) {
-        // Compute deadline utilization as the real-world time elapsed divided
+        // Compute encoder utilization as the real-world time elapsed divided
         // by the frame duration.
         const base::TimeDelta processing_time =
             base::TimeTicks::Now() - request.start_time;
-        encoded_frame->deadline_utilization =
+        encoded_frame->encoder_utilization =
             processing_time.InSecondsF() / frame_duration.InSecondsF();
 
         const double actual_bit_rate =
             encoded_frame->data.size() * 8.0 / frame_duration.InSecondsF();
         DCHECK_GT(request.target_bit_rate, 0);
         const double bitrate_utilization =
             actual_bit_rate / request.target_bit_rate;
         double quantizer = QuantizerEstimator::NO_RESULT;
         // If the quantizer can be parsed from the key frame, try to parse
         // the following delta frames as well.
@@ skipping 569 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media