Combine bytes-decoded notification with memory usage and frame count.

media/renderers/audio_renderer_impl.cc

 // Copyright (c) 2012 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/renderers/audio_renderer_impl.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
@@ skipping 28 matching lines @@
     ScopedVector<AudioDecoder> decoders,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       expecting_config_changes_(false),
       sink_(sink),
       audio_buffer_stream_(
           new AudioBufferStream(task_runner, std::move(decoders), media_log)),
       media_log_(media_log),
       client_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
+      bytes_decoded_(0),
       last_audio_memory_usage_(0),
       last_decoded_sample_rate_(0),
       playback_rate_(0.0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
@@ skipping 378 matching lines @@
                             AudioHardwareConfig::GetHighLatencyBufferSize(
                                 sample_rate, preferred_buffer_size));
   }
 
   audio_clock_.reset(
       new AudioClock(base::TimeDelta(), audio_parameters_.sample_rate()));
 
   audio_buffer_stream_->Initialize(
       stream, base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                          weak_factory_.GetWeakPtr()),
-      cdm_context, base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
-                              weak_factory_.GetWeakPtr()),
+      cdm_context,
+      base::Bind(&AudioRendererImpl::BytesDecoded, weak_factory_.GetWeakPtr()),
       base::Bind(&AudioRendererImpl::OnWaitingForDecryptionKey,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
 
@@ skipping 69 matching lines @@
 void AudioRendererImpl::OnSuspend() {
   base::AutoLock auto_lock(lock_);
   is_suspending_ = true;
 }
 
 void AudioRendererImpl::OnResume() {
   base::AutoLock auto_lock(lock_);
   is_suspending_ = false;
 }
 
+void AudioRendererImpl::BytesDecoded(uint64_t bytes) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  base::AutoLock auto_lock(lock_);
+
+  bytes_decoded_ += bytes;
+}
+
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
   DVLOG(2) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized);
 
   CHECK(pending_read_);
@@ skipping 106 matching lines @@
       algorithm_->EnqueueBuffer(buffer);
   }
 
   // Store the timestamp of the first packet so we know when to start actual
   // audio playback.
   if (first_packet_timestamp_ == kNoTimestamp())
     first_packet_timestamp_ = buffer->timestamp();
 
   const size_t memory_usage = algorithm_->GetMemoryUsage();
   PipelineStatistics stats;
+  stats.audio_bytes_decoded = bytes_decoded_;
   stats.audio_memory_usage = memory_usage - last_audio_memory_usage_;
+  bytes_decoded_ = 0;
   last_audio_memory_usage_ = memory_usage;
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&AudioRendererImpl::OnStatisticsUpdate,
                                     weak_factory_.GetWeakPtr(), stats));
 
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
       NOTREACHED();
@@ skipping 284 matching lines @@
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&AudioRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 }  // namespace media