Log MediaSource parsing errors to the MediaLog so they can appear in chrome:media-internals.

media/filters/source_buffer_stream.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/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 268 matching lines @@
   return base::TimeDelta::FromMilliseconds(1000);
 }
 // The maximum amount of data in bytes the stream will keep in memory.
 // 12MB: approximately 5 minutes of 320Kbps content.
 // 150MB: approximately 5 minutes of 4Mbps content.
 static int kDefaultAudioMemoryLimit = 12 * 1024 * 1024;
 static int kDefaultVideoMemoryLimit = 150 * 1024 * 1024;
 
 namespace media {
 
-SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config)
-    : current_config_index_(0),
+SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config,
+                                       const LogCB& log_cb)
+    : log_cb_(log_cb),
+      current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultAudioMemoryLimit),
       config_change_pending_(false) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(new AudioDecoderConfig());
   audio_configs_.back()->CopyFrom(audio_config);
 }
 
-SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config)
-    : current_config_index_(0),
+SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
+                                       const LogCB& log_cb)
+    : log_cb_(log_cb),
+      current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_buffer_timestamp_(kNoTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kDefaultVideoMemoryLimit),
@@ skipping 32 matching lines @@
   }
 }
 
 bool SourceBufferStream::Append(
     const SourceBufferStream::BufferQueue& buffers) {
   DCHECK(!buffers.empty());
   DCHECK(media_segment_start_time_ != kNoTimestamp());
 
   // New media segments must begin with a keyframe.
   if (new_media_segment_ && !buffers.front()->IsKeyframe()) {
-    DVLOG(1) << "Media segment did not begin with keyframe.";
+    MEDIA_LOG(log_cb_) <<"Media segment did not begin with keyframe.";
     return false;
   }
 
   // Buffers within a media segment should be monotonically increasing.
   if (!IsMonotonicallyIncreasing(buffers)) {
-    DVLOG(1) << "Buffers were not monotonically increasing.";
+    MEDIA_LOG(log_cb_) <<"Buffers were not monotonically increasing.";
     return false;
   }
 
   if (media_segment_start_time_ < base::TimeDelta() ||
       buffers.front()->GetDecodeTimestamp() < base::TimeDelta()) {
-    DVLOG(1) << "Cannot append a media segment with negative timestamps.";
+    MEDIA_LOG(log_cb_)
+        << "Cannot append a media segment with negative timestamps.";
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
   SetConfigIds(buffers);
 
   // Save a snapshot of stream state before range modifications are made.
   base::TimeDelta next_buffer_timestamp = GetNextBufferTimestamp();
   base::TimeDelta end_buffer_timestamp = GetEndBufferTimestamp();
 
@@ skipping 646 matching lines @@
   if (max_interbuffer_distance_ == kNoTimestamp())
     return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
   return max_interbuffer_distance_;
 }
 
 bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(!audio_configs_.empty());
   DCHECK(video_configs_.empty());
 
   if (audio_configs_[0]->codec() != config.codec()) {
-    DVLOG(1) << "UpdateAudioConfig() : Codec changes not allowed.";
+    MEDIA_LOG(log_cb_) << "Audio codec changes not allowed.";
     return false;
   }
 
   if (audio_configs_[0]->samples_per_second() != config.samples_per_second()) {
-    DVLOG(1) << "UpdateAudioConfig() : Sample rate changes not allowed.";
+    MEDIA_LOG(log_cb_) << "Audio sample rate changes not allowed.";
     return false;
   }
 
   if (audio_configs_[0]->channel_layout() != config.channel_layout()) {
-    DVLOG(1) << "UpdateAudioConfig() : Channel layout changes not allowed.";
+    MEDIA_LOG(log_cb_) << "Audio channel layout changes not allowed.";
     return false;
   }
 
   if (audio_configs_[0]->bits_per_channel() != config.bits_per_channel()) {
-    DVLOG(1) << "UpdateAudioConfig() : Bits per channel changes not allowed.";
+    MEDIA_LOG(log_cb_) << "Audio bits per channel changes not allowed.";
     return false;
   }
 
   // Check to see if the new config matches an existing one.
   for (size_t i = 0; i < audio_configs_.size(); ++i) {
     if (config.Matches(*audio_configs_[i])) {
       append_config_index_ = i;
       return true;
     }
   }
 
   // No matches found so let's add this one to the list.
   append_config_index_ = audio_configs_.size();
   audio_configs_.resize(audio_configs_.size() + 1);
   audio_configs_[append_config_index_] = new AudioDecoderConfig();
   audio_configs_[append_config_index_]->CopyFrom(config);
   return true;
 }
 
 bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
   DCHECK(!video_configs_.empty());
   DCHECK(audio_configs_.empty());
 
   if (video_configs_[0]->is_encrypted() != config.is_encrypted()) {
-    DVLOG(1) << "UpdateVideoConfig() : Encryption changes not allowed.";
+    MEDIA_LOG(log_cb_) <<"Video Encryption changes not allowed.";
     return false;
   }
 
   if (video_configs_[0]->codec() != config.codec()) {
-    DVLOG(1) << "UpdateVideoConfig() : Codec changes not allowed.";
+    MEDIA_LOG(log_cb_) <<"Video codec changes not allowed.";
     return false;
   }
 
   // Check to see if the new config matches an existing one.
   for (size_t i = 0; i < video_configs_.size(); ++i) {
     if (config.Matches(*video_configs_[i])) {
       append_config_index_ = i;
       return true;
     }
   }
@@ skipping 463 matching lines @@
   return ComputeFudgeRoom(GetApproximateDuration());
 }
 
 base::TimeDelta SourceBufferRange::GetApproximateDuration() const {
   base::TimeDelta max_interbuffer_distance = interbuffer_distance_cb_.Run();
   DCHECK(max_interbuffer_distance != kNoTimestamp());
   return max_interbuffer_distance;
 }
 
 }  // namespace media