Cap the memory usage in FFMpegDemuxer.

media/filters/ffmpeg_demuxer.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/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 298 matching lines @@
   // TODO(scherkus): Remove early return and reenable time-based capacity
   // after our data sources support canceling/concurrent reads, see
   // http://crbug.com/165762 for details.
   return !read_cb_.is_null();
 
   // Try to have one second's worth of encoded data per stream.
   const base::TimeDelta kCapacity = base::TimeDelta::FromSeconds(1);
   return buffer_queue_.IsEmpty() || buffer_queue_.Duration() < kCapacity;
 }
 
+int FFmpegDemuxerStream::MemoryUsage() const {
+  return buffer_queue_.data_size();
+}
+
 TextKind FFmpegDemuxerStream::GetTextKind() const {
   DCHECK_EQ(type_, DemuxerStream::TEXT);
 
   if (stream_->disposition & AV_DISPOSITION_CAPTIONS)
     return kTextCaptions;
 
   if (stream_->disposition & AV_DISPOSITION_DESCRIPTIONS)
     return kTextDescriptions;
 
   if (stream_->disposition & AV_DISPOSITION_METADATA)
@@ skipping 457 matching lines @@
 
 void FFmpegDemuxer::OnReadFrameDone(ScopedAVPacket packet, int result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(pending_read_);
   pending_read_ = false;
 
   if (!blocking_thread_.IsRunning() || pending_seek_) {
     return;
   }
 
-  if (result < 0) {
+  // Consider the stream as ended if:
+  // - either underlying ffmpeg returned an error
+  // - or FFMpegDemuxer reached the maximum allowed memory usage.
+  if (result < 0 || IsMaxMemoryReached()) {
     // Update the duration based on the highest elapsed time across all streams
     // if it was previously unknown.
     if (!duration_known_) {
       base::TimeDelta max_duration;
 
       for (StreamVector::iterator iter = streams_.begin();
            iter != streams_.end();
            ++iter) {
         if (!*iter)
           continue;
@@ skipping 86 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->HasAvailableCapacity()) {
       return true;
     }
   }
   return false;
 }
 
+bool FFmpegDemuxer::IsMaxMemoryReached() {

[damienv1, 2014/02/19 00:15:09]

Better design: have a MemoryUsage function (just like we have a MemoryUsage in
FFMpegDemuxerStream), do not compare against the memory limit here.

[damienv1, 2014/02/19 00:27:13]

Done.

+  DCHECK(task_runner_->BelongsToCurrentThread());
+  // Max allowed memory usage, all streams combined.
+  const int kMemoryLimit = 150 * 1024 * 1024;
+  int memory_usage = 0;
+  StreamVector::iterator iter;

[damienv1, 2014/02/19 00:27:13]

To be removed (already in the for loop).

+  for (StreamVector::iterator iter = streams_.begin();
+       iter != streams_.end(); ++iter) {
+    if (!(*iter))
+      continue;
+    DCHECK_LE((*iter)->MemoryUsage(),
+              std::numeric_limits<int>::max() - memory_usage);
+    memory_usage += (*iter)->MemoryUsage();

[acolwell GONE FROM CHROMIUM, 2014/02/18 23:57:49]

nit: I'm a little more worried about overflow here. How about we track
memory_free instead of memory_usage and early return if ((*iter)->MemoryUsage()
> memory_free). I think that might be a little safer.

[damienv1, 2014/02/19 00:27:13]

I was a bit worried as well. So I agree and I am going to add a condition
instead of a DCHECK.

+  }
+  return (memory_usage >= kMemoryLimit);
+}
+
 void FFmpegDemuxer::StreamHasEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (!*iter ||
         (audio_disabled_ && (*iter)->type() == DemuxerStream::AUDIO)) {
       continue;
     }
     (*iter)->SetEndOfStream();
   }
@@ skipping 27 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media