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

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 129 matching lines @@
       paused_(true),
       seeking_(false),
       ended_(false),
       pending_seek_(false),
       should_notify_time_changed_(false),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
       defer_load_cb_(params.defer_load_cb()),
       context_3d_cb_(params.context_3d_cb()),
+      adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
+      last_reported_memory_usage_(0),
       supports_save_(true),
       chunk_demuxer_(NULL),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(
           params.compositor_task_runner()
               ? params.compositor_task_runner()
               : base::MessageLoop::current()->task_runner()),
       compositor_(new VideoFrameCompositor(
           compositor_task_runner_,
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
@@ skipping 42 matching lines @@
 
   renderer_factory_.reset();
 
   // Make sure to kill the pipeline so there's no more media threads running.
   // Note: stopping the pipeline might block for a long time.
   base::WaitableEvent waiter(false, false);
   pipeline_.Stop(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
   waiter.Wait();
 
+  if (last_reported_memory_usage_)
+    adjust_allocated_memory_cb_.Run(-last_reported_memory_usage_);
+
   compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 }
 
 void WebMediaPlayerImpl::load(LoadType load_type, const blink::WebURL& url,
                               CORSMode cors_mode) {
   DVLOG(1) << __FUNCTION__ << "(" << load_type << ", " << url << ", "
            << cors_mode << ")";
@@ skipping 15 matching lines @@
                 GURL(frame_->document().securityOrigin().toString()));
 
   // Set subresource URL for crash reporting.
   base::debug::SetCrashKeyValue("subresource_url", gurl.spec());
 
   load_type_ = load_type;
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
+  memory_usage_reporting_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(500), this,

[xhwang, 2015/10/25 17:01:56]

Is 500ms recommended by v8? I know nothing about this area but just want to
double check....

[DaleCurtis, 2015/10/27 23:14:20]

Chosen arbitrarily. ulan@, jochen@ Does this value seem reasonable?

[ulan, 2015/10/28 13:22:09]

Yes, but the value is not v8 specific so I am not sure if it is better than any
other value.

+      &WebMediaPlayerImpl::ReportMemoryUsage);
 
   // Media source pipelines can start immediately.
   if (load_type == LoadTypeMediaSource) {
     supports_save_ = false;
     StartPipeline();
     return;
   }
 
   // Otherwise it's a regular request which requires resolving the URL first.
   data_source_.reset(new BufferedDataSource(
@@ skipping 819 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
+void WebMediaPlayerImpl::ReportMemoryUsage() {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+
+  const PipelineStatistics stats = pipeline_.GetStatistics();
+  const int64_t current_memory_usage =
+      stats.audio_memory_usage + stats.video_memory_usage +
+      (data_source_ ? data_source_->GetMemoryUsage() : 0) +
+      (demuxer_ ? demuxer_->GetMemoryUsage() : 0);
+
+  DVLOG(2) << "Memory Usage -- Audio: " << stats.audio_memory_usage
+           << ", Video: " << stats.video_memory_usage << ", DataSource: "
+           << (data_source_ ? data_source_->GetMemoryUsage() : 0)
+           << ", Demuxer: " << (demuxer_ ? demuxer_->GetMemoryUsage() : 0);
+
+  const int64_t delta = current_memory_usage - last_reported_memory_usage_;
+  last_reported_memory_usage_ = current_memory_usage;
+  adjust_allocated_memory_cb_.Run(delta);

[xhwang, 2015/10/25 17:01:56]

If |delta| is zero or very small, should we still report? (Not sure what's the
cost of this call :)

[DaleCurtis, 2015/10/27 23:14:20]

ulan@, jochen@: WDYT?

[ulan, 2015/10/28 13:22:09]

It is fine to report.

Zero delta would be a no-op, the cost is function call + several memory
accesses.

+}
+
 }  // namespace media