Add methods for telling V8 how much memory audio/video is using.

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 <algorithm>
 
@@ skipping 39 matching lines @@
     const AudioHardwareConfig& hardware_config,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       expecting_config_changes_(false),
       sink_(sink),
       audio_buffer_stream_(
           new AudioBufferStream(task_runner, decoders.Pass(), media_log)),
       hardware_config_(hardware_config),
       media_log_(media_log),
       tick_clock_(new base::DefaultTickClock()),
+      last_audio_memory_usage_(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),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
@@ skipping 257 matching lines @@
 
   state_ = kInitializing;
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
+  statistics_cb_ = statistics_cb;
 
   const AudioParameters& hw_params = hardware_config_.GetOutputConfig();
   expecting_config_changes_ = stream->SupportsConfigChanges();
   if (!expecting_config_changes_ || !hw_params.IsValid()) {
     // The actual buffer size is controlled via the size of the AudioBus
     // provided to Render(), so just choose something reasonable here for looks.
     int buffer_size = stream->audio_decoder_config().samples_per_second() / 100;
     audio_parameters_.Reset(
         AudioParameters::AUDIO_PCM_LOW_LATENCY,
         stream->audio_decoder_config().channel_layout(),
@@ skipping 160 matching lines @@
 
     if (state_ != kUninitialized)
       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_memory_usage = memory_usage - last_audio_memory_usage_;
+  last_audio_memory_usage_ = memory_usage;
+  task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, stats));
+
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
       NOTREACHED();
       return false;
 
     case kFlushed:
       DCHECK(!pending_read_);
       return false;
@@ skipping 271 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media