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

media/webm/webm_cluster_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/webm/webm_cluster_parser.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/webm_constants.h"
 
 namespace media {
 
 // Generates a 16 byte CTR counter block. The CTR counter block format is a
 // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV.
 // |iv_size| is the size of |iv| in btyes. Returns a string of
 // kDecryptionKeySize bytes.
 static std::string GenerateCounterBlock(const uint8* iv, int iv_size) {
   std::string counter_block(reinterpret_cast<const char*>(iv), iv_size);
   counter_block.append(DecryptConfig::kDecryptionKeySize - iv_size, 0);
   return counter_block;
 }
 
-WebMClusterParser::WebMClusterParser(int64 timecode_scale,
-                                     int audio_track_num,
-                                     int video_track_num,
-                                     const std::string& audio_encryption_key_id,
-                                     const std::string& video_encryption_key_id)
+WebMClusterParser::WebMClusterParser(
+    int64 timecode_scale, int audio_track_num, int video_track_num,
+    const std::string& audio_encryption_key_id,
+    const std::string& video_encryption_key_id,
+    const LogCB& log_cb)
     : timecode_multiplier_(timecode_scale / 1000.0),
       audio_encryption_key_id_(audio_encryption_key_id),
       video_encryption_key_id_(video_encryption_key_id),
       parser_(kWebMIdCluster, this),
       last_block_timecode_(-1),
       block_data_size_(-1),
       block_duration_(-1),
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
       audio_(audio_track_num),
-      video_(video_track_num) {
+      video_(video_track_num),
+      log_cb_(log_cb) {
 }
 
 WebMClusterParser::~WebMClusterParser() {}
 
 void WebMClusterParser::Reset() {
   last_block_timecode_ = -1;
   cluster_timecode_ = -1;
   cluster_start_time_ = kNoTimestamp();
   cluster_ended_ = false;
   parser_.Reset();
@@ skipping 46 matching lines @@
 
   return this;
 }
 
 bool WebMClusterParser::OnListEnd(int id) {
   if (id != kWebMIdBlockGroup)
     return true;
 
   // Make sure the BlockGroup actually had a Block.
   if (block_data_size_ == -1) {
-    DVLOG(1) << "Block missing from BlockGroup.";
+    MEDIA_LOG(log_cb_) << "Block missing from BlockGroup.";
     return false;
   }
 
   bool result = ParseBlock(block_data_.get(), block_data_size_,
                            block_duration_);
   block_data_.reset();
   block_data_size_ = -1;
   block_duration_ = -1;
   return result;
 }
@@ skipping 13 matching lines @@
   return true;
 }
 
 bool WebMClusterParser::ParseBlock(const uint8* buf, int size, int duration) {
   if (size < 4)
     return false;
 
   // Return an error if the trackNum > 127. We just aren't
   // going to support large track numbers right now.
   if (!(buf[0] & 0x80)) {
-    DVLOG(1) << "TrackNumber over 127 not supported";
+    MEDIA_LOG(log_cb_) << "TrackNumber over 127 not supported";
     return false;
   }
 
   int track_num = buf[0] & 0x7f;
   int timecode = buf[1] << 8 | buf[2];
   int flags = buf[3] & 0xff;
   int lacing = (flags >> 1) & 0x3;
 
   if (lacing) {
-    DVLOG(1) << "Lacing " << lacing << " not supported yet.";
+    MEDIA_LOG(log_cb_) << "Lacing " << lacing << " is not supported yet.";
     return false;
   }
 
   // Sign extend negative timecode offsets.
   if (timecode & 0x8000)
     timecode |= (-1 << 16);
 
   const uint8* frame_data = buf + 4;
   int frame_size = size - (frame_data - buf);
   return OnBlock(track_num, timecode, duration, flags, frame_data, frame_size);
 }
 
 bool WebMClusterParser::OnBinary(int id, const uint8* data, int size) {
   if (id == kWebMIdSimpleBlock)
     return ParseBlock(data, size, -1);
 
   if (id != kWebMIdBlock)
     return true;
 
   if (block_data_.get()) {
-    DVLOG(1) << "More than 1 Block in a BlockGroup is not supported.";
+    MEDIA_LOG(log_cb_) << "More than 1 Block in a BlockGroup is not supported.";
     return false;
   }
 
   block_data_.reset(new uint8[size]);
   memcpy(block_data_.get(), data, size);
   block_data_size_ = size;
   return true;
 }
 
 bool WebMClusterParser::OnBlock(int track_num, int timecode,
                                 int  block_duration,
                                 int flags,
                                 const uint8* data, int size) {
   DCHECK_GE(size, 0);
   if (cluster_timecode_ == -1) {
-    DVLOG(1) << "Got a block before cluster timecode.";
+    MEDIA_LOG(log_cb_) << "Got a block before cluster timecode.";
     return false;
   }
 
   if (timecode < 0) {
-    DVLOG(1) << "Got a block with negative timecode offset " << timecode;
+    MEDIA_LOG(log_cb_) << "Got a block with negative timecode offset "
+                       << timecode;
     return false;
   }
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
-    DVLOG(1) << "Got a block with a timecode before the previous block.";
+    MEDIA_LOG(log_cb_)
+        << "Got a block with a timecode before the previous block.";
     return false;
   }
 
   Track* track = NULL;
   std::string encryption_key_id;
   if (track_num == audio_.track_num()) {
     track = &audio_;
     encryption_key_id = audio_encryption_key_id_;
   } else if (track_num == video_.track_num()) {
     track = &video_;
     encryption_key_id = video_encryption_key_id_;
   } else {
-    DVLOG(1) << "Unexpected track number " << track_num;
+    MEDIA_LOG(log_cb_) << "Unexpected track number " << track_num;
     return false;
   }
 
   last_block_timecode_ = timecode;
 
   base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       (cluster_timecode_ + timecode) * timecode_multiplier_);
 
   // The first bit of the flags is set when the block contains only keyframes.
   // http://www.matroska.org/technical/specs/index.html
   bool is_keyframe = (flags & 0x80) != 0;
   scoped_refptr<StreamParserBuffer> buffer =
       StreamParserBuffer::CopyFrom(data, size, is_keyframe);
 
   // Every encrypted Block has a signal byte and IV prepended to it. Current
   // encrypted WebM request for comments specification is here
   // http://wiki.webmproject.org/encryption/webm-encryption-rfc
   if (!encryption_key_id.empty()) {
     DCHECK_EQ(kWebMSignalByteSize, 1);
     if (size < kWebMSignalByteSize) {
-      DVLOG(1) << "Got a block from an encrypted stream with no data.";
+      MEDIA_LOG(log_cb_)
+          << "Got a block from an encrypted stream with no data.";
       return false;
     }
     uint8 signal_byte = data[0];
     int data_offset = sizeof(signal_byte);
 
     // Setting the DecryptConfig object of the buffer while leaving the
     // initialization vector empty will tell the decryptor that the frame is
     // unencrypted.
     std::string counter_block;
 
     if (signal_byte & kWebMFlagEncryptedFrame) {
       if (size < kWebMSignalByteSize + kWebMIvSize) {
-        DVLOG(1) << "Got an encrypted block with not enough data " << size;
+        MEDIA_LOG(log_cb_) << "Got an encrypted block with not enough data "
+                           << size;
         return false;
       }
       counter_block = GenerateCounterBlock(data + data_offset, kWebMIvSize);
       data_offset += kWebMIvSize;
     }
 
     // TODO(fgalligan): Revisit if DecryptConfig needs to be set on unencrypted
     // frames after the CDM API is finalized.
     // Unencrypted frames of potentially encrypted streams currently set
     // DecryptConfig.
@@ skipping 32 matching lines @@
 
   buffers_.push_back(buffer);
   return true;
 }
 
 void WebMClusterParser::Track::Reset() {
   buffers_.clear();
 }
 
 }  // namespace media