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

media/mp4/mp4_stream_parser.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/mp4/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 24 matching lines @@
 }
 
 MP4StreamParser::~MP4StreamParser() {}
 
 void MP4StreamParser::Init(const InitCB& init_cb,
                            const NewConfigCB& config_cb,
                            const NewBuffersCB& audio_cb,
                            const NewBuffersCB& video_cb,
                            const NeedKeyCB& need_key_cb,
                            const NewMediaSegmentCB& new_segment_cb,
-                           const base::Closure& end_of_segment_cb) {
+                           const base::Closure& end_of_segment_cb,
+                           const LogCB& log_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!audio_cb.is_null() || !video_cb.is_null());
   DCHECK(!need_key_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingBoxes);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   audio_cb_ = audio_cb;
   video_cb_ = video_cb;
   need_key_cb_ = need_key_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
+  log_cb_ = log_cb;
 }
 
 void MP4StreamParser::Reset() {
   queue_.Reset();
   moov_.reset();
   runs_.reset();
   moof_head_ = 0;
   mdat_tail_ = 0;
 }
 
@@ skipping 41 matching lines @@
 
   return true;
 }
 
 bool MP4StreamParser::ParseBox(bool* err) {
   const uint8* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
-  scoped_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(buf, size, err));
+  scoped_ptr<BoxReader> reader(
+      BoxReader::ReadTopLevelBox(buf, size, log_cb_, err));
   if (reader.get() == NULL) return false;
 
   if (reader->type() == FOURCC_MOOV) {
     *err = !ParseMoov(reader.get());
   } else if (reader->type() == FOURCC_MOOF) {
     moof_head_ = queue_.head();
     *err = !ParseMoof(reader.get());
 
     // Set up first mdat offset for ReadMDATsUntil().
     mdat_tail_ = queue_.head() + reader->size();
 
     // Return early to avoid evicting 'moof' data from queue. Auxiliary info may
     // be located anywhere in the file, including inside the 'moof' itself.
     // (Since 'default-base-is-moof' is mandated, no data references can come
     // before the head of the 'moof', so keeping this box around is sufficient.)
     return !(*err);
   } else {
-    DVLOG(2) << "Skipping unrecognized top-level box: "
-             << FourCCToString(reader->type());
+    MEDIA_LOG(log_cb_) << "Skipping unrecognized top-level box: "
+                       << FourCCToString(reader->type());
   }
 
   queue_.Pop(reader->size());
   return !(*err);
 }
 
 
 bool MP4StreamParser::ParseMoov(BoxReader* reader) {
   moov_.reset(new Movie);
   RCHECK(moov_->Parse(reader));
-  runs_.reset(new TrackRunIterator(moov_.get()));
+  runs_.reset(new TrackRunIterator(moov_.get(), log_cb_));
 
   has_audio_ = false;
   has_video_ = false;
 
   AudioDecoderConfig audio_config;
   VideoDecoderConfig video_config;
 
   for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
        track != moov_->tracks.end(); ++track) {
     // TODO(strobe): Only the first audio and video track present in a file are
@@ skipping 241 matching lines @@
   std::vector<SubsampleEntry> subsamples;
   if (runs_->is_encrypted()) {
     decrypt_config = runs_->GetDecryptConfig();
     subsamples = decrypt_config->subsamples();
   }
 
   std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
   if (video) {
     if (!PrepareAVCBuffer(runs_->video_description().avcc,
                           &frame_buf, &subsamples)) {
-      DLOG(ERROR) << "Failed to prepare AVC sample for decode";
+      MEDIA_LOG(log_cb_) << "Failed to prepare AVC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (audio) {
     if (!PrepareAACBuffer(runs_->audio_description().esds.aac,
                           &frame_buf, &subsamples)) {
-      DLOG(ERROR) << "Failed to prepare AAC sample for decode";
+      MEDIA_LOG(log_cb_) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (decrypt_config.get() != NULL && !subsamples.empty()) {
     decrypt_config.reset(new DecryptConfig(
         decrypt_config->key_id(),
         decrypt_config->iv(),
         decrypt_config->data_offset(),
@@ skipping 44 matching lines @@
 
 bool MP4StreamParser::ReadAndDiscardMDATsUntil(const int64 offset) {
   bool err = false;
   while (mdat_tail_ < offset) {
     const uint8* buf;
     int size;
     queue_.PeekAt(mdat_tail_, &buf, &size);
 
     FourCC type;
     int box_sz;
-    if (!BoxReader::StartTopLevelBox(buf, size, &type, &box_sz, &err))
+    if (!BoxReader::StartTopLevelBox(buf, size, log_cb_,
+                                     &type, &box_sz, &err))
       break;
 
     if (type != FOURCC_MDAT) {
-      DLOG(WARNING) << "Unexpected box type while parsing MDATs: "
-                    << FourCCToString(type);
+      MEDIA_LOG(log_cb_) << "Unexpected box type while parsing MDATs: "
+                         << FourCCToString(type);
     }
     mdat_tail_ += box_sz;
   }
   queue_.Trim(std::min(mdat_tail_, offset));
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media