media/cast/sender: Rename deadline_utilization to encoder_utilization.

media/cast/sender/audio_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/audio_encoder.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 106 matching lines @@
                              TRACE_EVENT_SCOPE_THREAD,
                              "frames missed", num_frames_missed,
                              "samples dropped", samples_dropped_from_buffer_);
       }
     }
     frame_capture_time_ = recorded_time - buffer_fill_duration;
 
     // Encode all audio in |audio_bus| into zero or more frames.
     int src_pos = 0;
     while (src_pos < audio_bus->frames()) {
-      // Note: This is used to compute the deadline utilization and so it uses
+      // Note: This is used to compute the 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 = base::TimeTicks::Now();
 
       const int num_samples_to_xfer = std::min(
           samples_per_frame_ - buffer_fill_end_, audio_bus->frames() - src_pos);
       DCHECK_EQ(audio_bus->channels(), num_channels_);
       TransferSamplesIntoBuffer(
           audio_bus.get(), src_pos, buffer_fill_end_, num_samples_to_xfer);
       src_pos += num_samples_to_xfer;
       buffer_fill_end_ += num_samples_to_xfer;
 
       if (buffer_fill_end_ < samples_per_frame_)
         break;
 
       std::unique_ptr<SenderEncodedFrame> audio_frame(new SenderEncodedFrame());
       audio_frame->dependency = EncodedFrame::KEY;
       audio_frame->frame_id = frame_id_;
       audio_frame->referenced_frame_id = frame_id_;
       audio_frame->rtp_timestamp = frame_rtp_timestamp_;
       audio_frame->reference_time = frame_capture_time_;
 
       TRACE_EVENT_ASYNC_BEGIN2("cast.stream", "Audio Encode", audio_frame.get(),
                                "frame_id", frame_id_.lower_32_bits(),
                                "rtp_timestamp",
                                frame_rtp_timestamp_.lower_32_bits());
       if (EncodeFromFilledBuffer(&audio_frame->data)) {
-        // Compute deadline utilization as the real-world time elapsed divided
+        // Compute encoder utilization as the real-world time elapsed divided
         // by the signal duration.
-        audio_frame->deadline_utilization =
+        audio_frame->encoder_utilization =
             (base::TimeTicks::Now() - start_time).InSecondsF() /
-                frame_duration_.InSecondsF();
+            frame_duration_.InSecondsF();
 
         TRACE_EVENT_ASYNC_END1("cast.stream", "Audio Encode", audio_frame.get(),
-                               "Deadline utilization",
-                               audio_frame->deadline_utilization);
+                               "encoder_utilization",
+                               audio_frame->encoder_utilization);
 
         audio_frame->encode_completion_time =
             cast_environment_->Clock()->NowTicks();
         cast_environment_->PostTask(
             CastEnvironment::MAIN,
             FROM_HERE,
             base::Bind(callback_,
                        base::Passed(&audio_frame),
                        samples_dropped_from_buffer_));
         samples_dropped_from_buffer_ = 0;
@@ skipping 661 matching lines @@
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media