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

BUG=164673


Review URL: https://chromiumcodereview.appspot.com/11471006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@171936 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 85 insertions, 59 deletions

diff --git a/media/webm/webm_cluster_parser.cc b/media/webm/webm_cluster_parser.cc
index 477f668..4027f11 100644
--- a/media/webm/webm_cluster_parser.cc
+++ b/media/webm/webm_cluster_parser.cc
@@ -23,11 +23,11 @@ static std::string GenerateCounterBlock(const uint8* iv, int iv_size) {
   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),
@@ -39,7 +39,8 @@ WebMClusterParser::WebMClusterParser(int64 timecode_scale,
       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() {}
@@ -106,7 +107,7 @@ bool WebMClusterParser::OnListEnd(int id) {
 
   // 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;
   }
 
@@ -140,7 +141,7 @@ bool WebMClusterParser::ParseBlock(const uint8* buf, int size, int duration) {
   // 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;
   }
 
@@ -150,7 +151,7 @@ bool WebMClusterParser::ParseBlock(const uint8* buf, int size, int duration) {
   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;
   }
 
@@ -171,7 +172,7 @@ bool WebMClusterParser::OnBinary(int id, const uint8* data, int size) {
     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;
   }
 
@@ -187,17 +188,19 @@ bool WebMClusterParser::OnBlock(int track_num, int timecode,
                                 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;
   }
 
@@ -210,7 +213,7 @@ bool WebMClusterParser::OnBlock(int track_num, int timecode,
     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;
   }
 
@@ -231,7 +234,8 @@ bool WebMClusterParser::OnBlock(int track_num, int timecode,
   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];
@@ -244,7 +248,8 @@ bool WebMClusterParser::OnBlock(int track_num, int timecode,
 
     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);
diff --git a/media/webm/webm_cluster_parser.h b/media/webm/webm_cluster_parser.h
index 6748a28..f31a0cb 100644
--- a/media/webm/webm_cluster_parser.h
+++ b/media/webm/webm_cluster_parser.h
@@ -10,6 +10,7 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
+#include "media/base/media_log.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/webm/webm_parser.h"
 
@@ -23,7 +24,8 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
                     int audio_track_num,
                     int video_track_num,
                     const std::string& audio_encryption_key_id,
-                    const std::string& video_encryption_key_id);
+                    const std::string& video_encryption_key_id,
+                    const LogCB& log_cb);
   virtual ~WebMClusterParser();
 
   // Resets the parser state so it can accept a new cluster.
@@ -92,6 +94,8 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
   Track audio_;
   Track video_;
 
+  LogCB log_cb_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebMClusterParser);
 };
 
diff --git a/media/webm/webm_cluster_parser_unittest.cc b/media/webm/webm_cluster_parser_unittest.cc
index d12979f..f89e68f 100644
--- a/media/webm/webm_cluster_parser_unittest.cc
+++ b/media/webm/webm_cluster_parser_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "media/webm/cluster_builder.h"
 #include "media/webm/webm_cluster_parser.h"
@@ -124,9 +125,8 @@ static void AppendToEnd(const WebMClusterParser::BufferQueue& src,
 class WebMClusterParserTest : public testing::Test {
  public:
   WebMClusterParserTest()
-      : parser_(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum, kVideoTrackNum,
-                                      "", "")) {
+      : parser_(new WebMClusterParser(
+          kTimecodeScale, kAudioTrackNum, kVideoTrackNum, "", "", LogCB())) {
   }
 
  protected:
diff --git a/media/webm/webm_content_encodings_client.cc b/media/webm/webm_content_encodings_client.cc
index 2541e0b..bcf964e 100644
--- a/media/webm/webm_content_encodings_client.cc
+++ b/media/webm/webm_content_encodings_client.cc
@@ -10,8 +10,9 @@
 
 namespace media {
 
-WebMContentEncodingsClient::WebMContentEncodingsClient()
-    : content_encryption_encountered_(false),
+WebMContentEncodingsClient::WebMContentEncodingsClient(const LogCB& log_cb)
+    : log_cb_(log_cb),
+      content_encryption_encountered_(false),
       content_encodings_ready_(false) {
 }
 
@@ -43,7 +44,7 @@ WebMParserClient* WebMContentEncodingsClient::OnListStart(int id) {
   if (id == kWebMIdContentEncryption) {
     DCHECK(cur_content_encoding_.get());
     if (content_encryption_encountered_) {
-      DVLOG(1) << "Unexpected multiple ContentEncryption.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncryption.";
       return NULL;
     }
     content_encryption_encountered_ = true;
@@ -66,7 +67,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
   if (id == kWebMIdContentEncodings) {
     // ContentEncoding element is mandatory. Check this!
     if (content_encodings_.empty()) {
-      DVLOG(1) << "Missing ContentEncoding.";
+      MEDIA_LOG(log_cb_) << "Missing ContentEncoding.";
       return false;
     }
     content_encodings_ready_ = true;
@@ -84,7 +85,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
       // Default value of encoding order is 0, which should only be used on the
       // first ContentEncoding.
       if (!content_encodings_.empty()) {
-        DVLOG(1) << "Missing ContentEncodingOrder.";
+        MEDIA_LOG(log_cb_) << "Missing ContentEncodingOrder.";
         return false;
       }
       cur_content_encoding_->set_order(0);
@@ -98,15 +99,15 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
 
     // Check for elements valid in spec but not supported for now.
     if (cur_content_encoding_->type() == ContentEncoding::kTypeCompression) {
-      DVLOG(1) << "ContentCompression not supported.";
+      MEDIA_LOG(log_cb_) << "ContentCompression not supported.";
       return false;
     }
 
     // Enforce mandatory elements without default values.
     DCHECK(cur_content_encoding_->type() == ContentEncoding::kTypeEncryption);
     if (!content_encryption_encountered_) {
-      DVLOG(1) << "ContentEncodingType is encryption but ContentEncryption "
-                  "is missing.";
+      MEDIA_LOG(log_cb_) << "ContentEncodingType is encryption but"
+                         << " ContentEncryption is missing.";
       return false;
     }
 
@@ -145,13 +146,13 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingOrder) {
     if (cur_content_encoding_->order() != ContentEncoding::kOrderInvalid) {
-      DVLOG(1) << "Unexpected multiple ContentEncodingOrder.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncodingOrder.";
       return false;
     }
 
     if (val != static_cast<int64>(content_encodings_.size())) {
       // According to the spec, encoding order starts with 0 and counts upwards.
-      DVLOG(1) << "Unexpected ContentEncodingOrder.";
+      MEDIA_LOG(log_cb_) << "Unexpected ContentEncodingOrder.";
       return false;
     }
 
@@ -161,18 +162,18 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingScope) {
     if (cur_content_encoding_->scope() != ContentEncoding::kScopeInvalid) {
-      DVLOG(1) << "Unexpected multiple ContentEncodingScope.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncodingScope.";
       return false;
     }
 
     if (val == ContentEncoding::kScopeInvalid ||
         val > ContentEncoding::kScopeMax) {
-      DVLOG(1) << "Unexpected ContentEncodingScope.";
+      MEDIA_LOG(log_cb_) << "Unexpected ContentEncodingScope.";
       return false;
     }
 
     if (val & ContentEncoding::kScopeNextContentEncodingData) {
-      DVLOG(1) << "Encoded next ContentEncoding is not supported.";
+      MEDIA_LOG(log_cb_) << "Encoded next ContentEncoding is not supported.";
       return false;
     }
 
@@ -182,17 +183,17 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingType) {
     if (cur_content_encoding_->type() != ContentEncoding::kTypeInvalid) {
-      DVLOG(1) << "Unexpected multiple ContentEncodingType.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncodingType.";
       return false;
     }
 
     if (val == ContentEncoding::kTypeCompression) {
-      DVLOG(1) << "ContentCompression not supported.";
+      MEDIA_LOG(log_cb_) << "ContentCompression not supported.";
       return false;
     }
 
     if (val != ContentEncoding::kTypeEncryption) {
-      DVLOG(1) << "Unexpected ContentEncodingType " << val << ".";
+      MEDIA_LOG(log_cb_) << "Unexpected ContentEncodingType " << val << ".";
       return false;
     }
 
@@ -203,13 +204,13 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
   if (id == kWebMIdContentEncAlgo) {
     if (cur_content_encoding_->encryption_algo() !=
         ContentEncoding::kEncAlgoInvalid) {
-      DVLOG(1) << "Unexpected multiple ContentEncAlgo.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncAlgo.";
       return false;
     }
 
     if (val < ContentEncoding::kEncAlgoNotEncrypted ||
         val > ContentEncoding::kEncAlgoAes) {
-      DVLOG(1) << "Unexpected ContentEncAlgo " << val << ".";
+      MEDIA_LOG(log_cb_) << "Unexpected ContentEncAlgo " << val << ".";
       return false;
     }
 
@@ -221,12 +222,12 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
   if (id == kWebMIdAESSettingsCipherMode) {
     if (cur_content_encoding_->cipher_mode() !=
         ContentEncoding::kCipherModeInvalid) {
-      DVLOG(1) << "Unexpected multiple AESSettingsCipherMode.";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple AESSettingsCipherMode.";
       return false;
     }
 
     if (val != ContentEncoding::kCipherModeCtr) {
-      DVLOG(1) << "Unexpected AESSettingsCipherMode " << val << ".";
+      MEDIA_LOG(log_cb_) << "Unexpected AESSettingsCipherMode " << val << ".";
       return false;
     }
 
@@ -249,7 +250,7 @@ bool WebMContentEncodingsClient::OnBinary(int id, const uint8* data, int size) {
 
   if (id == kWebMIdContentEncKeyID) {
     if (!cur_content_encoding_->encryption_key_id().empty()) {
-      DVLOG(1) << "Unexpected multiple ContentEncKeyID";
+      MEDIA_LOG(log_cb_) << "Unexpected multiple ContentEncKeyID";
       return false;
     }
     cur_content_encoding_->SetEncryptionKeyId(data, size);
diff --git a/media/webm/webm_content_encodings_client.h b/media/webm/webm_content_encodings_client.h
index 257d37d..e477fcf3 100644
--- a/media/webm/webm_content_encodings_client.h
+++ b/media/webm/webm_content_encodings_client.h
@@ -7,9 +7,11 @@
 
 #include <vector>
 
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
+#include "media/base/media_log.h"
 #include "media/webm/webm_content_encodings.h"
 #include "media/webm/webm_parser.h"
 
@@ -20,7 +22,7 @@ typedef std::vector<ContentEncoding*> ContentEncodings;
 // Parser for WebM ContentEncodings element.
 class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient {
  public:
-  WebMContentEncodingsClient();
+  explicit WebMContentEncodingsClient(const LogCB& log_cb);
   virtual ~WebMContentEncodingsClient();
 
   const ContentEncodings& content_encodings() const;
@@ -32,6 +34,7 @@ class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient {
   virtual bool OnBinary(int id, const uint8* data, int size) OVERRIDE;
 
  private:
+  LogCB log_cb_;
   scoped_ptr<ContentEncoding> cur_content_encoding_;
   bool content_encryption_encountered_;
   ContentEncodings content_encodings_;
diff --git a/media/webm/webm_content_encodings_client_unittest.cc b/media/webm/webm_content_encodings_client_unittest.cc
index bf45bd7..bb9e694 100644
--- a/media/webm/webm_content_encodings_client_unittest.cc
+++ b/media/webm/webm_content_encodings_client_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/bind.h"
 #include "media/webm/webm_constants.h"
 #include "media/webm/webm_content_encodings_client.h"
 #include "media/webm/webm_parser.h"
@@ -12,7 +13,8 @@ namespace media {
 class WebMContentEncodingsClientTest : public testing::Test {
  public:
   WebMContentEncodingsClientTest()
-      : parser_(kWebMIdContentEncodings, &client_) {}
+      : client_(LogCB()),
+        parser_(kWebMIdContentEncodings, &client_) {}
 
   void ParseAndExpectToFail(const uint8* buf, int size) {
     int result = parser_.Parse(buf, size);
diff --git a/media/webm/webm_stream_parser.cc b/media/webm/webm_stream_parser.cc
index 89e85d7..dfa56c3 100644
--- a/media/webm/webm_stream_parser.cc
+++ b/media/webm/webm_stream_parser.cc
@@ -186,7 +186,8 @@ void WebMStreamParser::Init(const InitCB& init_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());
@@ -204,6 +205,7 @@ void WebMStreamParser::Init(const InitCB& init_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 WebMStreamParser::Flush() {
@@ -305,9 +307,10 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
     case kWebMIdInfo:
       // We've found the element we are looking for.
       break;
-    default:
-      DVLOG(1) << "Unexpected ID 0x" << std::hex << id;
+    default: {
+      MEDIA_LOG(log_cb_) << "Unexpected element ID 0x" << std::hex << id;
       return -1;
+    }
   }
 
   WebMInfoParser info_parser;
@@ -320,7 +323,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   cur_size -= result;
   bytes_parsed += result;
 
-  WebMTracksParser tracks_parser;
+  WebMTracksParser tracks_parser(log_cb_);
   result = tracks_parser.Parse(cur, cur_size);
 
   if (result <= 0)
@@ -393,7 +396,8 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
       tracks_parser.audio_track_num(),
       tracks_parser.video_track_num(),
       tracks_parser.audio_encryption_key_id(),
-      tracks_parser.video_encryption_key_id()));
+      tracks_parser.video_encryption_key_id(),
+      log_cb_));
 
   ChangeState(kParsingClusters);
 
diff --git a/media/webm/webm_stream_parser.h b/media/webm/webm_stream_parser.h
index 3640151..c98805a 100644
--- a/media/webm/webm_stream_parser.h
+++ b/media/webm/webm_stream_parser.h
@@ -27,7 +27,8 @@ class WebMStreamParser : public StreamParser {
                     const NewBuffersCB& video_cb,
                     const NeedKeyCB& need_key_cb,
                     const NewMediaSegmentCB& new_segment_cb,
-                    const base::Closure& end_of_segment_cb) OVERRIDE;
+                    const base::Closure& end_of_segment_cb,
+                    const LogCB& log_cb) OVERRIDE;
   virtual void Flush() OVERRIDE;
   virtual bool Parse(const uint8* buf, int size) OVERRIDE;
 
@@ -71,6 +72,7 @@ class WebMStreamParser : public StreamParser {
   NeedKeyCB need_key_cb_;
   NewMediaSegmentCB new_segment_cb_;
   base::Closure end_of_segment_cb_;
+  LogCB log_cb_;
 
   // True if a new cluster id has been seen, but no audio or video buffers have
   // been parsed yet.
diff --git a/media/webm/webm_tracks_parser.cc b/media/webm/webm_tracks_parser.cc
index 7232285..8a8864d 100644
--- a/media/webm/webm_tracks_parser.cc
+++ b/media/webm/webm_tracks_parser.cc
@@ -16,11 +16,12 @@ namespace media {
 static const int kWebMTrackTypeVideo = 1;
 static const int kWebMTrackTypeAudio = 2;
 
-WebMTracksParser::WebMTracksParser()
+WebMTracksParser::WebMTracksParser(const LogCB& log_cb)
     : track_type_(-1),
       track_num_(-1),
       audio_track_num_(-1),
-      video_track_num_(-1) {
+      video_track_num_(-1),
+      log_cb_(log_cb) {
 }
 
 WebMTracksParser::~WebMTracksParser() {}
@@ -44,7 +45,8 @@ int WebMTracksParser::Parse(const uint8* buf, int size) {
 WebMParserClient* WebMTracksParser::OnListStart(int id) {
   if (id == kWebMIdContentEncodings) {
     DCHECK(!track_content_encodings_client_.get());
-    track_content_encodings_client_.reset(new WebMContentEncodingsClient);
+    track_content_encodings_client_.reset(
+        new WebMContentEncodingsClient(log_cb_));
     return track_content_encodings_client_->OnListStart(id);
   }
 
@@ -65,15 +67,15 @@ bool WebMTracksParser::OnListEnd(int id) {
 
   if (id == kWebMIdTrackEntry) {
     if (track_type_ == -1 || track_num_ == -1) {
-      DVLOG(1) << "Missing TrackEntry data"
-               << " TrackType " << track_type_
-               << " TrackNum " << track_num_;
+      MEDIA_LOG(log_cb_) << "Missing TrackEntry data for "
+                         << " TrackType " << track_type_
+                         << " TrackNum " << track_num_;
       return false;
     }
 
     if (track_type_ != kWebMTrackTypeAudio &&
         track_type_ != kWebMTrackTypeVideo) {
-      DVLOG(1) << "Unexpected TrackType " << track_type_;
+      MEDIA_LOG(log_cb_) << "Unexpected TrackType " << track_type_;
       return false;
     }
 
@@ -118,7 +120,8 @@ bool WebMTracksParser::OnUInt(int id, int64 val) {
   }
 
   if (*dst != -1) {
-    DVLOG(1) << "Multiple values for id " << std::hex << id << " specified";
+    MEDIA_LOG(log_cb_) << "Multiple values for id " << std::hex << id
+                       << " specified";
     return false;
   }
 
@@ -136,7 +139,7 @@ bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) {
 
 bool WebMTracksParser::OnString(int id, const std::string& str) {
   if (id == kWebMIdCodecID && str != "A_VORBIS" && str != "V_VP8") {
-    DVLOG(1) << "Unexpected CodecID " << str;
+    MEDIA_LOG(log_cb_) << "Unexpected CodecID " << str;
     return false;
   }
 
diff --git a/media/webm/webm_tracks_parser.h b/media/webm/webm_tracks_parser.h
index 02d43d6..897ef42 100644
--- a/media/webm/webm_tracks_parser.h
+++ b/media/webm/webm_tracks_parser.h
@@ -9,6 +9,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "media/base/media_log.h"
 #include "media/webm/webm_content_encodings_client.h"
 #include "media/webm/webm_parser.h"
 
@@ -17,7 +18,7 @@ namespace media {
 // Parser for WebM Tracks element.
 class WebMTracksParser : public WebMParserClient {
  public:
-  explicit WebMTracksParser();
+  explicit WebMTracksParser(const LogCB& log_cb);
   virtual ~WebMTracksParser();
 
   // Parses a WebM Tracks element in |buf|.
@@ -53,6 +54,7 @@ class WebMTracksParser : public WebMParserClient {
   int64 video_track_num_;
   std::string audio_encryption_key_id_;
   std::string video_encryption_key_id_;
+  LogCB log_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMTracksParser);
 };