Revert "Fix race on demuxer memory usage. Reuse previous calculation."

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 "base/base64.h"
 #include "base/bind.h"
@@ skipping 730 matching lines @@
       pending_seek_(false),
       data_source_(data_source),
       media_log_(media_log),
       bitrate_(0),
       start_time_(kNoTimestamp()),
       preferred_stream_for_seeking_(-1, kNoTimestamp()),
       fallback_stream_for_seeking_(-1, kNoTimestamp()),
       text_enabled_(false),
       duration_known_(false),
       encrypted_media_init_data_cb_(encrypted_media_init_data_cb),
-      stream_memory_usage_(0),
       weak_factory_(this) {
   DCHECK(task_runner_.get());
   DCHECK(data_source_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {}
 
 void FFmpegDemuxer::Stop() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 156 matching lines @@
     std::string language = stream->GetMetadata("language");
 
     // TODO: Implement "id" metadata in FFMPEG.
     // See: http://crbug.com/323183
     host_->AddTextStream(stream, TextTrackConfig(kind, title, language,
         std::string()));
   }
 }
 
 int64_t FFmpegDemuxer::GetMemoryUsage() const {
-  base::AutoLock locker(stream_memory_usage_lock_);
-  return stream_memory_usage_;
+  int64_t allocation_size = 0;
+  for (const auto& stream : streams_) {
+    if (stream)
+      allocation_size += stream->MemoryUsage();
+  }
+  return allocation_size;
 }
 
 // Helper for calculating the bitrate of the media based on information stored
 // in |format_context| or failing that the size and duration of the media.
 //
 // Returns 0 if a bitrate could not be determined.
 static int CalculateBitrate(
     AVFormatContext* format_context,
     const base::TimeDelta& duration,
     int64 filesize_in_bytes) {
@@ skipping 432 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;
   }
 
-  // Max allowed memory usage, all streams combined.
-  const int64_t kDemuxerMemoryLimit = 150 * 1024 * 1024;
-  const bool is_max_memory_usage_reached =
-      UpdateMemoryUsage() > kDemuxerMemoryLimit;
-
   // Consider the stream as ended if:
   // - either underlying ffmpeg returned an error
   // - or FFMpegDemuxer reached the maximum allowed memory usage.
-  if (result < 0 || is_max_memory_usage_reached) {
+  if (result < 0 || IsMaxMemoryUsageReached()) {
     // 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 45 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;
 }
 
-int64_t FFmpegDemuxer::UpdateMemoryUsage() {
+bool FFmpegDemuxer::IsMaxMemoryUsageReached() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  base::AutoLock locker(stream_memory_usage_lock_);
-  stream_memory_usage_ = 0;
-  for (const auto& stream : streams_) {
-    if (stream)
-      stream_memory_usage_ += stream->MemoryUsage();
+  // Max allowed memory usage, all streams combined.
+  const size_t kDemuxerMemoryLimit = 150 * 1024 * 1024;
+
+  size_t memory_left = kDemuxerMemoryLimit;
+  for (StreamVector::const_iterator iter = streams_.begin();
+       iter != streams_.end(); ++iter) {
+    if (!(*iter))
+      continue;
+
+    size_t stream_memory_usage = (*iter)->MemoryUsage();
+    if (stream_memory_usage > memory_left)
+      return true;
+    memory_left -= stream_memory_usage;
   }
-  return stream_memory_usage_;
+  return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (!*iter)
       continue;
     (*iter)->SetEndOfStream();
   }
@@ skipping 36 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {  // |stream| is a ref to a pointer.
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media