Deprecate LogCB in favor of using MediaLog

Now that MEDIA_LOG macros work with a MediaLog, and having a MediaLog
object is needed to log events like property changes (not just strings),
this CL replaces usage of bound LogCB with actual MediaLog object
throughout //media. It also removes LogCB.

BUG=499628
R=xhwang@chromium.org,chcunningham@chromium.org,gunsch@chromium.org
TEST=No media unittest or layout test regression locally on linux with proprietary codecs including mp2t enabled

Review URL: https://codereview.chromium.org/1235793005

Cr-Commit-Position: refs/heads/master@{#338710}

15 files changed, 188 insertions, 238 deletions

diff --git a/media/formats/webm/webm_audio_client.cc b/media/formats/webm/webm_audio_client.cc
index ea911ec..90ac4a8 100644
--- a/media/formats/webm/webm_audio_client.cc
+++ b/media/formats/webm/webm_audio_client.cc
@@ -10,8 +10,8 @@
 
 namespace media {
 
-WebMAudioClient::WebMAudioClient(const LogCB& log_cb)
-    : log_cb_(log_cb) {
+WebMAudioClient::WebMAudioClient(const scoped_refptr<MediaLog>& media_log)
+    : media_log_(media_log) {
   Reset();
 }
 
@@ -37,7 +37,7 @@ bool WebMAudioClient::InitializeConfig(
   } else if (codec_id == "A_OPUS") {
     audio_codec = kCodecOpus;
   } else {
-    MEDIA_LOG(ERROR, log_cb_) << "Unsupported audio codec_id " << codec_id;
+    MEDIA_LOG(ERROR, media_log_) << "Unsupported audio codec_id " << codec_id;
     return false;
   }
 
@@ -51,7 +51,7 @@ bool WebMAudioClient::InitializeConfig(
   ChannelLayout channel_layout =  GuessChannelLayout(channels_);
 
   if (channel_layout == CHANNEL_LAYOUT_UNSUPPORTED) {
-    MEDIA_LOG(ERROR, log_cb_) << "Unsupported channel count " << channels_;
+    MEDIA_LOG(ERROR, media_log_) << "Unsupported channel count " << channels_;
     return false;
   }
 
@@ -100,9 +100,9 @@ bool WebMAudioClient::InitializeConfig(
 bool WebMAudioClient::OnUInt(int id, int64 val) {
   if (id == kWebMIdChannels) {
     if (channels_ != -1) {
-      MEDIA_LOG(ERROR, log_cb_) << "Multiple values for id " << std::hex << id
-                                << " specified. (" << channels_ << " and "
-                                << val << ")";
+      MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex
+                                   << id << " specified. (" << channels_
+                                   << " and " << val << ")";
       return false;
     }
 
@@ -129,9 +129,9 @@ bool WebMAudioClient::OnFloat(int id, double val) {
     return false;
 
   if (*dst != -1) {
-    MEDIA_LOG(ERROR, log_cb_) << "Multiple values for id " << std::hex << id
-                              << " specified (" << *dst << " and " << val
-                              << ")";
+    MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex << id
+                                 << " specified (" << *dst << " and " << val
+                                 << ")";
     return false;
   }
 
diff --git a/media/formats/webm/webm_audio_client.h b/media/formats/webm/webm_audio_client.h
index 2e23c13..67f5f01 100644
--- a/media/formats/webm/webm_audio_client.h
+++ b/media/formats/webm/webm_audio_client.h
@@ -17,7 +17,7 @@ class AudioDecoderConfig;
 // Helper class used to parse an Audio element inside a TrackEntry element.
 class WebMAudioClient : public WebMParserClient {
  public:
-  explicit WebMAudioClient(const LogCB& log_cb);
+  explicit WebMAudioClient(const scoped_refptr<MediaLog>& media_log);
   ~WebMAudioClient() override;
 
   // Reset this object's state so it can process a new audio track element.
@@ -41,7 +41,7 @@ class WebMAudioClient : public WebMParserClient {
   bool OnUInt(int id, int64 val) override;
   bool OnFloat(int id, double val) override;
 
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
   int channels_;
   double samples_per_second_;
   double output_samples_per_second_;
diff --git a/media/formats/webm/webm_cluster_parser.cc b/media/formats/webm/webm_cluster_parser.cc
index a76559d..d530f0a 100644
--- a/media/formats/webm/webm_cluster_parser.cc
+++ b/media/formats/webm/webm_cluster_parser.cc
@@ -42,7 +42,7 @@ WebMClusterParser::WebMClusterParser(
     const std::string& audio_encryption_key_id,
     const std::string& video_encryption_key_id,
     const AudioCodec audio_codec,
-    const LogCB& log_cb)
+    const scoped_refptr<MediaLog>& media_log)
     : num_duration_errors_(0),
       timecode_multiplier_(timecode_scale / 1000.0),
       ignored_tracks_(ignored_tracks),
@@ -59,15 +59,15 @@ WebMClusterParser::WebMClusterParser(
       cluster_timecode_(-1),
       cluster_start_time_(kNoTimestamp()),
       cluster_ended_(false),
-      audio_(audio_track_num, false, audio_default_duration, log_cb),
-      video_(video_track_num, true, video_default_duration, log_cb),
+      audio_(audio_track_num, false, audio_default_duration, media_log),
+      video_(video_track_num, true, video_default_duration, media_log),
       ready_buffer_upper_bound_(kNoDecodeTimestamp()),
-      log_cb_(log_cb) {
+      media_log_(media_log) {
   for (WebMTracksParser::TextTracks::const_iterator it = text_tracks.begin();
        it != text_tracks.end();
        ++it) {
     text_track_map_.insert(std::make_pair(
-        it->first, Track(it->first, false, kNoTimestamp(), log_cb_)));
+        it->first, Track(it->first, false, kNoTimestamp(), media_log_)));
   }
 }
 
@@ -188,7 +188,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
       base::TimeDelta::FromMilliseconds(120);
 
   if (size < 1) {
-    LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+    LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                       kMaxDurationErrorLogs)
         << "Invalid zero-byte Opus packet; demuxed block duration may be "
            "imprecise.";
@@ -210,7 +210,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
     case 3:
       // Type 3 indicates an arbitrary frame count described in the next byte.
       if (size < 2) {
-        LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+        LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "Second byte missing from 'Code 3' Opus packet; demuxed block "
                "duration may be imprecise.";
@@ -220,7 +220,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
       frame_count = data[1] & kFrameCountMask;
 
       if (frame_count == 0) {
-        LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+        LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "Illegal 'Code 3' Opus packet with frame count zero; demuxed "
                "block duration may be imprecise.";
@@ -229,7 +229,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
 
       break;
     default:
-      LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+      LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                         kMaxDurationErrorLogs)
           << "Unexpected Opus frame count type: " << frame_count_type << "; "
           << "demuxed block duration may be imprecise.";
@@ -248,7 +248,7 @@ base::TimeDelta WebMClusterParser::ReadOpusDuration(const uint8_t* data,
     // Intentionally allowing packet to pass through for now. Decoder should
     // either handle or fail gracefully. MEDIA_LOG as breadcrumbs in case
     // things go sideways.
-    LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+    LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                       kMaxDurationErrorLogs)
         << "Warning, demuxed Opus packet with encoded duration: " << duration
         << ". Should be no greater than " << kPacketDurationMax;
@@ -282,7 +282,7 @@ bool WebMClusterParser::OnListEnd(int id) {
 
   // Make sure the BlockGroup actually had a Block.
   if (block_data_size_ == -1) {
-    MEDIA_LOG(ERROR, log_cb_) << "Block missing from BlockGroup.";
+    MEDIA_LOG(ERROR, media_log_) << "Block missing from BlockGroup.";
     return false;
   }
 
@@ -335,7 +335,7 @@ bool WebMClusterParser::ParseBlock(bool is_simple_block,
   // Return an error if the trackNum > 127. We just aren't
   // going to support large track numbers right now.
   if (!(buf[0] & 0x80)) {
-    MEDIA_LOG(ERROR, log_cb_) << "TrackNumber over 127 not supported";
+    MEDIA_LOG(ERROR, media_log_) << "TrackNumber over 127 not supported";
     return false;
   }
 
@@ -345,8 +345,8 @@ bool WebMClusterParser::ParseBlock(bool is_simple_block,
   int lacing = (flags >> 1) & 0x3;
 
   if (lacing) {
-    MEDIA_LOG(ERROR, log_cb_) << "Lacing " << lacing
-                              << " is not supported yet.";
+    MEDIA_LOG(ERROR, media_log_) << "Lacing " << lacing
+                                 << " is not supported yet.";
     return false;
   }
 
@@ -368,8 +368,9 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) {
 
     case kWebMIdBlock:
       if (block_data_) {
-        MEDIA_LOG(ERROR, log_cb_) << "More than 1 Block in a BlockGroup is not "
-                                     "supported.";
+        MEDIA_LOG(ERROR, media_log_)
+            << "More than 1 Block in a BlockGroup is not "
+               "supported.";
         return false;
       }
       block_data_.reset(new uint8_t[size]);
@@ -384,8 +385,8 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) {
         // as per matroska spec. But for now we don't have a use case to
         // support parsing of such files. Take a look at this again when such a
         // case arises.
-        MEDIA_LOG(ERROR, log_cb_) << "More than 1 BlockAdditional in a "
-                                     "BlockGroup is not supported.";
+        MEDIA_LOG(ERROR, media_log_) << "More than 1 BlockAdditional in a "
+                                        "BlockGroup is not supported.";
         return false;
       }
       // First 8 bytes of side_data in DecoderBuffer is the BlockAddID
@@ -427,20 +428,20 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
                                 int64 discard_padding) {
   DCHECK_GE(size, 0);
   if (cluster_timecode_ == -1) {
-    MEDIA_LOG(ERROR, log_cb_) << "Got a block before cluster timecode.";
+    MEDIA_LOG(ERROR, media_log_) << "Got a block before cluster timecode.";
     return false;
   }
 
   // TODO(acolwell): Should relative negative timecode offsets be rejected?  Or
   // only when the absolute timecode is negative?  See http://crbug.com/271794
   if (timecode < 0) {
-    MEDIA_LOG(ERROR, log_cb_) << "Got a block with negative timecode offset "
-                              << timecode;
+    MEDIA_LOG(ERROR, media_log_) << "Got a block with negative timecode offset "
+                                 << timecode;
     return false;
   }
 
   if (last_block_timecode_ != -1 && timecode < last_block_timecode_) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << "Got a block with a timecode before the previous block.";
     return false;
   }
@@ -469,7 +470,7 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
     track = text_track;
     buffer_type = DemuxerStream::TEXT;
   } else {
-    MEDIA_LOG(ERROR, log_cb_) << "Unexpected track number " << track_num;
+    MEDIA_LOG(ERROR, media_log_) << "Unexpected track number " << track_num;
     return false;
   }
 
@@ -567,7 +568,7 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
       const auto kWarnDurationDiff =
           base::TimeDelta::FromMicroseconds(timecode_multiplier_ * 2);
       if (duration_difference.magnitude() > kWarnDurationDiff) {
-        LIMITED_MEDIA_LOG(DEBUG, log_cb_, num_duration_errors_,
+        LIMITED_MEDIA_LOG(DEBUG, media_log_, num_duration_errors_,
                           kMaxDurationErrorLogs)
             << "BlockDuration "
             << "(" << block_duration_time_delta << ") "
@@ -594,13 +595,13 @@ bool WebMClusterParser::OnBlock(bool is_simple_block,
 WebMClusterParser::Track::Track(int track_num,
                                 bool is_video,
                                 base::TimeDelta default_duration,
-                                const LogCB& log_cb)
+                                const scoped_refptr<MediaLog>& media_log)
     : num_duration_estimates_(0),
       track_num_(track_num),
       is_video_(is_video),
       default_duration_(default_duration),
       estimated_next_frame_duration_(kNoTimestamp()),
-      log_cb_(log_cb) {
+      media_log_(media_log) {
   DCHECK(default_duration_ == kNoTimestamp() ||
          default_duration_ > base::TimeDelta());
 }
@@ -700,7 +701,7 @@ void WebMClusterParser::Track::ApplyDurationEstimateIfNeeded() {
     last_added_buffer_missing_duration_->set_is_duration_estimated(true);
   }
 
-  LIMITED_MEDIA_LOG(INFO, log_cb_, num_duration_estimates_,
+  LIMITED_MEDIA_LOG(INFO, media_log_, num_duration_estimates_,
                     kMaxDurationEstimateLogs)
       << "Estimating WebM block duration to be " << estimated_duration << " "
       << "for the last (Simple)Block in the Cluster for this Track. Use "
@@ -768,7 +769,7 @@ bool WebMClusterParser::Track::QueueBuffer(
 
   base::TimeDelta duration = buffer->duration();
   if (duration < base::TimeDelta() || duration == kNoTimestamp()) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << "Invalid buffer duration: " << duration.InSecondsF();
     return false;
   }
diff --git a/media/formats/webm/webm_cluster_parser.h b/media/formats/webm/webm_cluster_parser.h
index 0eef986..d1b34a8 100644
--- a/media/formats/webm/webm_cluster_parser.h
+++ b/media/formats/webm/webm_cluster_parser.h
@@ -51,7 +51,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
     Track(int track_num,
           bool is_video,
           base::TimeDelta default_duration,
-          const LogCB& log_cb);
+          const scoped_refptr<MediaLog>& media_log);
     ~Track();
 
     int track_num() const { return track_num_; }
@@ -143,7 +143,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
     // splicing when these estimates are observed in SourceBufferStream.
     base::TimeDelta estimated_next_frame_duration_;
 
-    LogCB log_cb_;
+    scoped_refptr<MediaLog> media_log_;
   };
 
   typedef std::map<int, Track> TextTrackMap;
@@ -158,8 +158,8 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
                     const std::set<int64>& ignored_tracks,
                     const std::string& audio_encryption_key_id,
                     const std::string& video_encryption_key_id,
-                    const AudioCodec audio_codec_,
-                    const LogCB& log_cb);
+                    const AudioCodec audio_codec,
+                    const scoped_refptr<MediaLog>& media_log);
   ~WebMClusterParser() override;
 
   // Resets the parser state so it can accept a new cluster.
@@ -315,7 +315,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
   // kInfiniteDuration() if no buffers are currently missing duration.
   DecodeTimestamp ready_buffer_upper_bound_;
 
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebMClusterParser);
 };
diff --git a/media/formats/webm/webm_cluster_parser_unittest.cc b/media/formats/webm/webm_cluster_parser_unittest.cc
index 4020df4..43d75ea 100644
--- a/media/formats/webm/webm_cluster_parser_unittest.cc
+++ b/media/formats/webm/webm_cluster_parser_unittest.cc
@@ -268,7 +268,7 @@ class WebMClusterParserTest : public testing::Test {
                                       std::string(),
                                       std::string(),
                                       kUnknownAudioCodec,
-                                      LogCB())) {}
+                                      new MediaLog())) {}
 
  protected:
   void ResetParserToHaveDefaultDurations() {
@@ -281,17 +281,10 @@ class WebMClusterParserTest : public testing::Test {
     ASSERT_NE(kNoTimestamp(), default_audio_duration);
     ASSERT_NE(kNoTimestamp(), default_video_duration);
 
-    parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                        kAudioTrackNum,
-                                        default_audio_duration,
-                                        kVideoTrackNum,
-                                        default_video_duration,
-                                        TextTracks(),
-                                        std::set<int64>(),
-                                        std::string(),
-                                        std::string(),
-                                        kUnknownAudioCodec,
-                                        LogCB()));
+    parser_.reset(new WebMClusterParser(
+        kTimecodeScale, kAudioTrackNum, default_audio_duration, kVideoTrackNum,
+        default_video_duration, TextTracks(), std::set<int64>(), std::string(),
+        std::string(), kUnknownAudioCodec, new MediaLog()));
   }
 
   scoped_ptr<WebMClusterParser> parser_;
@@ -317,17 +310,10 @@ TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
       base::TimeDelta::FromMilliseconds(kTestAudioFrameDefaultDurationInMs);
   ASSERT_GE(default_audio_duration, base::TimeDelta());
   ASSERT_NE(kNoTimestamp(), default_audio_duration);
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      default_audio_duration,
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      text_tracks,
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, default_audio_duration, kVideoTrackNum,
+      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kBlockInfo[] = {
       {kVideoTrackNum, 0, 33, true, NULL, 0},
@@ -510,17 +496,10 @@ TEST_F(WebMClusterParserTest, IgnoredTracks) {
   std::set<int64> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      TextTracks(),
-                                      ignored_tracks,
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), ignored_tracks, std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
@@ -556,17 +535,10 @@ TEST_F(WebMClusterParserTest, ParseTextTracks) {
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      text_tracks,
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
@@ -594,17 +566,10 @@ TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      text_tracks,
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
@@ -632,17 +597,10 @@ TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
                                     TextTrackConfig(kTextCaptions, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      text_tracks,
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kInputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
@@ -679,17 +637,10 @@ TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
 TEST_F(WebMClusterParserTest, ParseEncryptedBlock) {
   scoped_ptr<Cluster> cluster(CreateEncryptedCluster(sizeof(kEncryptedFrame)));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      TextTracks(),
-                                      std::set<int64>(),
-                                      std::string(),
-                                      "video_key_id",
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
+      "video_key_id", kUnknownAudioCodec, new MediaLog()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_EQ(1UL, parser_->GetVideoBuffers().size());
@@ -701,17 +652,10 @@ TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
   scoped_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      TextTracks(),
-                                      std::set<int64>(),
-                                      std::string(),
-                                      "video_key_id",
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
+      "video_key_id", kUnknownAudioCodec, new MediaLog()));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
@@ -741,17 +685,10 @@ TEST_F(WebMClusterParserTest, ParseInvalidTextBlockGroupWithoutDuration) {
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
-  parser_.reset(new WebMClusterParser(kTimecodeScale,
-                                      kAudioTrackNum,
-                                      kNoTimestamp(),
-                                      kVideoTrackNum,
-                                      kNoTimestamp(),
-                                      text_tracks,
-                                      std::set<int64>(),
-                                      std::string(),
-                                      std::string(),
-                                      kUnknownAudioCodec,
-                                      LogCB()));
+  parser_.reset(new WebMClusterParser(
+      kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
+      kNoTimestamp(), text_tracks, std::set<int64>(), std::string(),
+      std::string(), kUnknownAudioCodec, new MediaLog()));
 
   const BlockInfo kBlockInfo[] = {
     { kTextTrackNum,  33, -42, false },
@@ -1002,7 +939,7 @@ TEST_F(WebMClusterParserTest, ReadOpusDurationsSimpleBlockAtEndOfCluster) {
   parser_.reset(new WebMClusterParser(
       kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
       kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      std::string(), kCodecOpus, LogCB()));
+      std::string(), kCodecOpus, new MediaLog()));
 
   int loop_count = 0;
   for (const auto* packet_ptr : BuildAllOpusPackets()) {
@@ -1030,7 +967,7 @@ TEST_F(WebMClusterParserTest, PreferOpusDurationsOverBlockDurations) {
   parser_.reset(new WebMClusterParser(
       kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
       kNoTimestamp(), TextTracks(), std::set<int64>(), std::string(),
-      std::string(), kCodecOpus, LogCB()));
+      std::string(), kCodecOpus, new MediaLog()));
 
   int loop_count = 0;
   for (const auto* packet_ptr : BuildAllOpusPackets()) {
@@ -1072,7 +1009,7 @@ TEST_F(WebMClusterParserTest, DontReadEncodedDurationWhenEncrypted) {
   parser_.reset(new WebMClusterParser(
       kTimecodeScale, kAudioTrackNum, kNoTimestamp(), kVideoTrackNum,
       kNoTimestamp(), TextTracks(), std::set<int64>(), audio_encryption_id,
-      std::string(), kCodecOpus, LogCB()));
+      std::string(), kCodecOpus, new MediaLog()));
 
   // Single Block with BlockDuration and encrypted data.
   const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
diff --git a/media/formats/webm/webm_content_encodings_client.cc b/media/formats/webm/webm_content_encodings_client.cc
index 7265df9..a9783dd 100644
--- a/media/formats/webm/webm_content_encodings_client.cc
+++ b/media/formats/webm/webm_content_encodings_client.cc
@@ -10,8 +10,9 @@
 
 namespace media {
 
-WebMContentEncodingsClient::WebMContentEncodingsClient(const LogCB& log_cb)
-    : log_cb_(log_cb),
+WebMContentEncodingsClient::WebMContentEncodingsClient(
+    const scoped_refptr<MediaLog>& media_log)
+    : media_log_(media_log),
       content_encryption_encountered_(false),
       content_encodings_ready_(false) {
 }
@@ -44,7 +45,7 @@ WebMParserClient* WebMContentEncodingsClient::OnListStart(int id) {
   if (id == kWebMIdContentEncryption) {
     DCHECK(cur_content_encoding_.get());
     if (content_encryption_encountered_) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncryption.";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected multiple ContentEncryption.";
       return NULL;
     }
     content_encryption_encountered_ = true;
@@ -67,7 +68,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
   if (id == kWebMIdContentEncodings) {
     // ContentEncoding element is mandatory. Check this!
     if (content_encodings_.empty()) {
-      MEDIA_LOG(ERROR, log_cb_) << "Missing ContentEncoding.";
+      MEDIA_LOG(ERROR, media_log_) << "Missing ContentEncoding.";
       return false;
     }
     content_encodings_ready_ = true;
@@ -85,7 +86,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()) {
-        MEDIA_LOG(ERROR, log_cb_) << "Missing ContentEncodingOrder.";
+        MEDIA_LOG(ERROR, media_log_) << "Missing ContentEncodingOrder.";
         return false;
       }
       cur_content_encoding_->set_order(0);
@@ -99,15 +100,15 @@ bool WebMContentEncodingsClient::OnListEnd(int id) {
 
     // Check for elements valid in spec but not supported for now.
     if (cur_content_encoding_->type() == ContentEncoding::kTypeCompression) {
-      MEDIA_LOG(ERROR, log_cb_) << "ContentCompression not supported.";
+      MEDIA_LOG(ERROR, media_log_) << "ContentCompression not supported.";
       return false;
     }
 
     // Enforce mandatory elements without default values.
     DCHECK(cur_content_encoding_->type() == ContentEncoding::kTypeEncryption);
     if (!content_encryption_encountered_) {
-      MEDIA_LOG(ERROR, log_cb_) << "ContentEncodingType is encryption but"
-                                << " ContentEncryption is missing.";
+      MEDIA_LOG(ERROR, media_log_) << "ContentEncodingType is encryption but"
+                                   << " ContentEncryption is missing.";
       return false;
     }
 
@@ -146,13 +147,14 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingOrder) {
     if (cur_content_encoding_->order() != ContentEncoding::kOrderInvalid) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncodingOrder.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "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.
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected ContentEncodingOrder.";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncodingOrder.";
       return false;
     }
 
@@ -162,19 +164,20 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingScope) {
     if (cur_content_encoding_->scope() != ContentEncoding::kScopeInvalid) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncodingScope.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "Unexpected multiple ContentEncodingScope.";
       return false;
     }
 
     if (val == ContentEncoding::kScopeInvalid ||
         val > ContentEncoding::kScopeMax) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected ContentEncodingScope.";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncodingScope.";
       return false;
     }
 
     if (val & ContentEncoding::kScopeNextContentEncodingData) {
-      MEDIA_LOG(ERROR, log_cb_) << "Encoded next ContentEncoding is not "
-                                   "supported.";
+      MEDIA_LOG(ERROR, media_log_) << "Encoded next ContentEncoding is not "
+                                      "supported.";
       return false;
     }
 
@@ -184,18 +187,19 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
 
   if (id == kWebMIdContentEncodingType) {
     if (cur_content_encoding_->type() != ContentEncoding::kTypeInvalid) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncodingType.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "Unexpected multiple ContentEncodingType.";
       return false;
     }
 
     if (val == ContentEncoding::kTypeCompression) {
-      MEDIA_LOG(ERROR, log_cb_) << "ContentCompression not supported.";
+      MEDIA_LOG(ERROR, media_log_) << "ContentCompression not supported.";
       return false;
     }
 
     if (val != ContentEncoding::kTypeEncryption) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected ContentEncodingType " << val
-                                << ".";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncodingType " << val
+                                   << ".";
       return false;
     }
 
@@ -206,13 +210,14 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
   if (id == kWebMIdContentEncAlgo) {
     if (cur_content_encoding_->encryption_algo() !=
         ContentEncoding::kEncAlgoInvalid) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncAlgo.";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected multiple ContentEncAlgo.";
       return false;
     }
 
     if (val < ContentEncoding::kEncAlgoNotEncrypted ||
         val > ContentEncoding::kEncAlgoAes) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected ContentEncAlgo " << val << ".";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncAlgo " << val
+                                   << ".";
       return false;
     }
 
@@ -224,13 +229,14 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) {
   if (id == kWebMIdAESSettingsCipherMode) {
     if (cur_content_encoding_->cipher_mode() !=
         ContentEncoding::kCipherModeInvalid) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple AESSettingsCipherMode.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "Unexpected multiple AESSettingsCipherMode.";
       return false;
     }
 
     if (val != ContentEncoding::kCipherModeCtr) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected AESSettingsCipherMode " << val
-                                << ".";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected AESSettingsCipherMode " << val
+                                   << ".";
       return false;
     }
 
@@ -253,7 +259,7 @@ bool WebMContentEncodingsClient::OnBinary(int id, const uint8* data, int size) {
 
   if (id == kWebMIdContentEncKeyID) {
     if (!cur_content_encoding_->encryption_key_id().empty()) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected multiple ContentEncKeyID";
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected multiple ContentEncKeyID";
       return false;
     }
     cur_content_encoding_->SetEncryptionKeyId(data, size);
diff --git a/media/formats/webm/webm_content_encodings_client.h b/media/formats/webm/webm_content_encodings_client.h
index 4b1bfe0..85f7bf3 100644
--- a/media/formats/webm/webm_content_encodings_client.h
+++ b/media/formats/webm/webm_content_encodings_client.h
@@ -22,7 +22,7 @@ typedef std::vector<ContentEncoding*> ContentEncodings;
 // Parser for WebM ContentEncodings element.
 class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient {
  public:
-  explicit WebMContentEncodingsClient(const LogCB& log_cb);
+  explicit WebMContentEncodingsClient(const scoped_refptr<MediaLog>& media_log);
   ~WebMContentEncodingsClient() override;
 
   const ContentEncodings& content_encodings() const;
@@ -34,7 +34,7 @@ class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient {
   bool OnBinary(int id, const uint8* data, int size) override;
 
  private:
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
   scoped_ptr<ContentEncoding> cur_content_encoding_;
   bool content_encryption_encountered_;
   ContentEncodings content_encodings_;
diff --git a/media/formats/webm/webm_content_encodings_client_unittest.cc b/media/formats/webm/webm_content_encodings_client_unittest.cc
index e124f2d..22049eb 100644
--- a/media/formats/webm/webm_content_encodings_client_unittest.cc
+++ b/media/formats/webm/webm_content_encodings_client_unittest.cc
@@ -13,8 +13,7 @@ namespace media {
 class WebMContentEncodingsClientTest : public testing::Test {
  public:
   WebMContentEncodingsClientTest()
-      : client_(LogCB()),
-        parser_(kWebMIdContentEncodings, &client_) {}
+      : client_(new MediaLog()), parser_(kWebMIdContentEncodings, &client_) {}
 
   void ParseAndExpectToFail(const uint8* buf, int size) {
     int result = parser_.Parse(buf, size);
diff --git a/media/formats/webm/webm_stream_parser.cc b/media/formats/webm/webm_stream_parser.cc
index 95a4eb0..74bad20 100644
--- a/media/formats/webm/webm_stream_parser.cc
+++ b/media/formats/webm/webm_stream_parser.cc
@@ -33,7 +33,7 @@ void WebMStreamParser::Init(
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewMediaSegmentCB& new_segment_cb,
     const base::Closure& end_of_segment_cb,
-    const LogCB& log_cb) {
+    const scoped_refptr<MediaLog>& media_log) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
@@ -51,7 +51,7 @@ void WebMStreamParser::Init(
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
-  log_cb_ = log_cb;
+  media_log_ = media_log;
 }
 
 void WebMStreamParser::Flush() {
@@ -154,7 +154,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
       break;
     case kWebMIdCluster:
       if (!cluster_parser_) {
-        MEDIA_LOG(ERROR, log_cb_) << "Found Cluster element before Info.";
+        MEDIA_LOG(ERROR, media_log_) << "Found Cluster element before Info.";
         return -1;
       }
       ChangeState(kParsingClusters);
@@ -172,7 +172,8 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
       // We've found the element we are looking for.
       break;
     default: {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected element ID 0x" << std::hex << id;
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected element ID 0x" << std::hex
+                                   << id;
       return -1;
     }
   }
@@ -187,7 +188,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   cur_size -= result;
   bytes_parsed += result;
 
-  WebMTracksParser tracks_parser(log_cb_, ignore_text_tracks_);
+  WebMTracksParser tracks_parser(media_log_, ignore_text_tracks_);
   result = tracks_parser.Parse(cur, cur_size);
 
   if (result <= 0)
@@ -230,17 +231,14 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) {
   }
 
   cluster_parser_.reset(new WebMClusterParser(
-      info_parser.timecode_scale(),
-      tracks_parser.audio_track_num(),
+      info_parser.timecode_scale(), tracks_parser.audio_track_num(),
       tracks_parser.GetAudioDefaultDuration(timecode_scale_in_us),
       tracks_parser.video_track_num(),
       tracks_parser.GetVideoDefaultDuration(timecode_scale_in_us),
-      tracks_parser.text_tracks(),
-      tracks_parser.ignored_tracks(),
+      tracks_parser.text_tracks(), tracks_parser.ignored_tracks(),
       tracks_parser.audio_encryption_key_id(),
-      tracks_parser.video_encryption_key_id(),
-      audio_config.codec(),
-      log_cb_));
+      tracks_parser.video_encryption_key_id(), audio_config.codec(),
+      media_log_));
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(params);
diff --git a/media/formats/webm/webm_stream_parser.h b/media/formats/webm/webm_stream_parser.h
index e808413..cb95804 100644
--- a/media/formats/webm/webm_stream_parser.h
+++ b/media/formats/webm/webm_stream_parser.h
@@ -30,7 +30,7 @@ class WebMStreamParser : public StreamParser {
             const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
             const NewMediaSegmentCB& new_segment_cb,
             const base::Closure& end_of_segment_cb,
-            const LogCB& log_cb) override;
+            const scoped_refptr<MediaLog>& media_log) override;
   void Flush() override;
   bool Parse(const uint8* buf, int size) override;
 
@@ -75,7 +75,7 @@ class WebMStreamParser : public StreamParser {
 
   NewMediaSegmentCB new_segment_cb_;
   base::Closure end_of_segment_cb_;
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
 
   bool unknown_segment_size_;
 
diff --git a/media/formats/webm/webm_tracks_parser.cc b/media/formats/webm/webm_tracks_parser.cc
index 86bb0a7..0c2cd8e 100644
--- a/media/formats/webm/webm_tracks_parser.cc
+++ b/media/formats/webm/webm_tracks_parser.cc
@@ -43,7 +43,8 @@ static base::TimeDelta PrecisionCappedDefaultDuration(
   return base::TimeDelta::FromMicroseconds(mult);
 }
 
-WebMTracksParser::WebMTracksParser(const LogCB& log_cb, bool ignore_text_tracks)
+WebMTracksParser::WebMTracksParser(const scoped_refptr<MediaLog>& media_log,
+                                   bool ignore_text_tracks)
     : track_type_(-1),
       track_num_(-1),
       seek_preroll_(-1),
@@ -54,9 +55,9 @@ WebMTracksParser::WebMTracksParser(const LogCB& log_cb, bool ignore_text_tracks)
       video_track_num_(-1),
       video_default_duration_(-1),
       ignore_text_tracks_(ignore_text_tracks),
-      log_cb_(log_cb),
-      audio_client_(log_cb),
-      video_client_(log_cb) {
+      media_log_(media_log),
+      audio_client_(media_log),
+      video_client_(media_log) {
 }
 
 WebMTracksParser::~WebMTracksParser() {}
@@ -102,7 +103,7 @@ WebMParserClient* WebMTracksParser::OnListStart(int id) {
   if (id == kWebMIdContentEncodings) {
     DCHECK(!track_content_encodings_client_.get());
     track_content_encodings_client_.reset(
-        new WebMContentEncodingsClient(log_cb_));
+        new WebMContentEncodingsClient(media_log_));
     return track_content_encodings_client_->OnListStart(id);
   }
 
@@ -136,9 +137,9 @@ bool WebMTracksParser::OnListEnd(int id) {
 
   if (id == kWebMIdTrackEntry) {
     if (track_type_ == -1 || track_num_ == -1) {
-      MEDIA_LOG(ERROR, log_cb_) << "Missing TrackEntry data for "
-                                << " TrackType " << track_type_ << " TrackNum "
-                                << track_num_;
+      MEDIA_LOG(ERROR, media_log_) << "Missing TrackEntry data for "
+                                   << " TrackType " << track_type_
+                                   << " TrackNum " << track_num_;
       return false;
     }
 
@@ -146,7 +147,7 @@ bool WebMTracksParser::OnListEnd(int id) {
         track_type_ != kWebMTrackTypeVideo &&
         track_type_ != kWebMTrackTypeSubtitlesOrCaptions &&
         track_type_ != kWebMTrackTypeDescriptionsOrMetadata) {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected TrackType " << track_type_;
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected TrackType " << track_type_;
       return false;
     }
 
@@ -154,29 +155,29 @@ bool WebMTracksParser::OnListEnd(int id) {
     if (track_type_ == kWebMTrackTypeSubtitlesOrCaptions) {
       text_track_kind = CodecIdToTextKind(codec_id_);
       if (text_track_kind == kTextNone) {
-        MEDIA_LOG(ERROR, log_cb_) << "Missing TrackEntry CodecID"
-                                  << " TrackNum " << track_num_;
+        MEDIA_LOG(ERROR, media_log_) << "Missing TrackEntry CodecID"
+                                     << " TrackNum " << track_num_;
         return false;
       }
 
       if (text_track_kind != kTextSubtitles &&
           text_track_kind != kTextCaptions) {
-        MEDIA_LOG(ERROR, log_cb_) << "Wrong TrackEntry CodecID"
-                                  << " TrackNum " << track_num_;
+        MEDIA_LOG(ERROR, media_log_) << "Wrong TrackEntry CodecID"
+                                     << " TrackNum " << track_num_;
         return false;
       }
     } else if (track_type_ == kWebMTrackTypeDescriptionsOrMetadata) {
       text_track_kind = CodecIdToTextKind(codec_id_);
       if (text_track_kind == kTextNone) {
-        MEDIA_LOG(ERROR, log_cb_) << "Missing TrackEntry CodecID"
-                                  << " TrackNum " << track_num_;
+        MEDIA_LOG(ERROR, media_log_) << "Missing TrackEntry CodecID"
+                                     << " TrackNum " << track_num_;
         return false;
       }
 
       if (text_track_kind != kTextDescriptions &&
           text_track_kind != kTextMetadata) {
-        MEDIA_LOG(ERROR, log_cb_) << "Wrong TrackEntry CodecID"
-                                  << " TrackNum " << track_num_;
+        MEDIA_LOG(ERROR, media_log_) << "Wrong TrackEntry CodecID"
+                                     << " TrackNum " << track_num_;
         return false;
       }
     }
@@ -196,8 +197,8 @@ bool WebMTracksParser::OnListEnd(int id) {
         audio_encryption_key_id_ = encryption_key_id;
 
         if (default_duration_ == 0) {
-          MEDIA_LOG(ERROR, log_cb_) << "Illegal 0ns audio TrackEntry "
-                                       "DefaultDuration";
+          MEDIA_LOG(ERROR, media_log_) << "Illegal 0ns audio TrackEntry "
+                                          "DefaultDuration";
           return false;
         }
         audio_default_duration_ = default_duration_;
@@ -209,7 +210,7 @@ bool WebMTracksParser::OnListEnd(int id) {
           return false;
         }
       } else {
-        MEDIA_LOG(DEBUG, log_cb_) << "Ignoring audio track " << track_num_;
+        MEDIA_LOG(DEBUG, media_log_) << "Ignoring audio track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
     } else if (track_type_ == kWebMTrackTypeVideo) {
@@ -218,8 +219,8 @@ bool WebMTracksParser::OnListEnd(int id) {
         video_encryption_key_id_ = encryption_key_id;
 
         if (default_duration_ == 0) {
-          MEDIA_LOG(ERROR, log_cb_) << "Illegal 0ns video TrackEntry "
-                                       "DefaultDuration";
+          MEDIA_LOG(ERROR, media_log_) << "Illegal 0ns video TrackEntry "
+                                          "DefaultDuration";
           return false;
         }
         video_default_duration_ = default_duration_;
@@ -231,13 +232,13 @@ bool WebMTracksParser::OnListEnd(int id) {
           return false;
         }
       } else {
-        MEDIA_LOG(DEBUG, log_cb_) << "Ignoring video track " << track_num_;
+        MEDIA_LOG(DEBUG, media_log_) << "Ignoring video track " << track_num_;
         ignored_tracks_.insert(track_num_);
       }
     } else if (track_type_ == kWebMTrackTypeSubtitlesOrCaptions ||
                track_type_ == kWebMTrackTypeDescriptionsOrMetadata) {
       if (ignore_text_tracks_) {
-        MEDIA_LOG(DEBUG, log_cb_) << "Ignoring text track " << track_num_;
+        MEDIA_LOG(DEBUG, media_log_) << "Ignoring text track " << track_num_;
         ignored_tracks_.insert(track_num_);
       } else {
         std::string track_num = base::Int64ToString(track_num_);
@@ -245,7 +246,7 @@ bool WebMTracksParser::OnListEnd(int id) {
             text_track_kind, track_name_, track_language_, track_num);
       }
     } else {
-      MEDIA_LOG(ERROR, log_cb_) << "Unexpected TrackType " << track_type_;
+      MEDIA_LOG(ERROR, media_log_) << "Unexpected TrackType " << track_type_;
       return false;
     }
 
@@ -290,8 +291,8 @@ bool WebMTracksParser::OnUInt(int id, int64 val) {
   }
 
   if (*dst != -1) {
-    MEDIA_LOG(ERROR, log_cb_) << "Multiple values for id " << std::hex << id
-                              << " specified";
+    MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex << id
+                                 << " specified";
     return false;
   }
 
@@ -306,7 +307,8 @@ bool WebMTracksParser::OnFloat(int id, double val) {
 bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) {
   if (id == kWebMIdCodecPrivate) {
     if (!codec_private_.empty()) {
-      MEDIA_LOG(ERROR, log_cb_) << "Multiple CodecPrivate fields in a track.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "Multiple CodecPrivate fields in a track.";
       return false;
     }
     codec_private_.assign(data, data + size);
@@ -318,7 +320,7 @@ bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) {
 bool WebMTracksParser::OnString(int id, const std::string& str) {
   if (id == kWebMIdCodecID) {
     if (!codec_id_.empty()) {
-      MEDIA_LOG(ERROR, log_cb_) << "Multiple CodecID fields in a track";
+      MEDIA_LOG(ERROR, media_log_) << "Multiple CodecID fields in a track";
       return false;
     }
 
diff --git a/media/formats/webm/webm_tracks_parser.h b/media/formats/webm/webm_tracks_parser.h
index 2801a3e..d5513b5 100644
--- a/media/formats/webm/webm_tracks_parser.h
+++ b/media/formats/webm/webm_tracks_parser.h
@@ -27,7 +27,8 @@ namespace media {
 // Parser for WebM Tracks element.
 class MEDIA_EXPORT WebMTracksParser : public WebMParserClient {
  public:
-  explicit WebMTracksParser(const LogCB& log_cb, bool ignore_text_tracks);
+  WebMTracksParser(const scoped_refptr<MediaLog>& media_log,
+                   bool ignore_text_tracks);
   ~WebMTracksParser() override;
 
   // Parses a WebM Tracks element in |buf|.
@@ -102,7 +103,7 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient {
   std::set<int64> ignored_tracks_;
   std::string audio_encryption_key_id_;
   std::string video_encryption_key_id_;
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
 
   WebMAudioClient audio_client_;
   AudioDecoderConfig audio_decoder_config_;
diff --git a/media/formats/webm/webm_tracks_parser_unittest.cc b/media/formats/webm/webm_tracks_parser_unittest.cc
index 2f85ddc..39854ef 100644
--- a/media/formats/webm/webm_tracks_parser_unittest.cc
+++ b/media/formats/webm/webm_tracks_parser_unittest.cc
@@ -29,7 +29,8 @@ static void VerifyTextTrackInfo(const uint8* buffer,
                                 TextKind text_kind,
                                 const std::string& name,
                                 const std::string& language) {
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), false));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), false));
 
   int result = parser->Parse(buffer, buffer_size);
   EXPECT_GT(result, 0);
@@ -95,7 +96,8 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) {
   tb.AddTextTrack(2, 2, kWebMCodecSubtitles, "Commentary", "fre");
 
   const std::vector<uint8> buf = tb.Finish();
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), true));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), true));
 
   int result = parser->Parse(&buf[0], buf.size());
   EXPECT_GT(result, 0);
@@ -108,7 +110,7 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) {
   EXPECT_TRUE(ignored_tracks.find(2) != ignored_tracks.end());
 
   // Test again w/o ignoring the test tracks.
-  parser.reset(new WebMTracksParser(LogCB(), false));
+  parser.reset(new WebMTracksParser(new MediaLog(), false));
 
   result = parser->Parse(&buf[0], buf.size());
   EXPECT_GT(result, 0);
@@ -128,7 +130,8 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationUnset) {
   tb.AddVideoTrack(2, 2, "V_VP8", "video", "", -1, 320, 240);
   const std::vector<uint8> buf = tb.Finish();
 
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), true));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), true));
   int result = parser->Parse(&buf[0], buf.size());
   EXPECT_LE(0, result);
   EXPECT_EQ(static_cast<int>(buf.size()), result);
@@ -157,7 +160,8 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationSet) {
   tb.AddVideoTrack(2, 2, "V_VP8", "video", "", 987654321, 320, 240);
   const std::vector<uint8> buf = tb.Finish();
 
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), true));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), true));
   int result = parser->Parse(&buf[0], buf.size());
   EXPECT_LE(0, result);
   EXPECT_EQ(static_cast<int>(buf.size()), result);
@@ -179,7 +183,8 @@ TEST_F(WebMTracksParserTest, InvalidZeroDefaultDurationSet) {
   tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", 0, 2, 8000);
   const std::vector<uint8> buf = tb.Finish();
 
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), true));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), true));
   EXPECT_EQ(-1, parser->Parse(&buf[0], buf.size()));
 }
 
@@ -190,7 +195,8 @@ TEST_F(WebMTracksParserTest, HighTrackUID) {
   tb.AddAudioTrack(1, 1ULL << 31, "A_VORBIS", "audio", "", 40, 2, 8000);
   const std::vector<uint8> buf = tb.Finish();
 
-  scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(LogCB(), true));
+  scoped_ptr<WebMTracksParser> parser(
+      new WebMTracksParser(new MediaLog(), true));
   EXPECT_GT(parser->Parse(&buf[0], buf.size()),0);
 }
 
diff --git a/media/formats/webm/webm_video_client.cc b/media/formats/webm/webm_video_client.cc
index 54fee16..ef8bc0f 100644
--- a/media/formats/webm/webm_video_client.cc
+++ b/media/formats/webm/webm_video_client.cc
@@ -9,8 +9,8 @@
 
 namespace media {
 
-WebMVideoClient::WebMVideoClient(const LogCB& log_cb)
-    : log_cb_(log_cb) {
+WebMVideoClient::WebMVideoClient(const scoped_refptr<MediaLog>& media_log)
+    : media_log_(media_log) {
   Reset();
 }
 
@@ -44,7 +44,7 @@ bool WebMVideoClient::InitializeConfig(
     video_codec = kCodecVP9;
     profile = VP9PROFILE_ANY;
   } else {
-    MEDIA_LOG(ERROR, log_cb_) << "Unsupported video codec_id " << codec_id;
+    MEDIA_LOG(ERROR, media_log_) << "Unsupported video codec_id " << codec_id;
     return false;
   }
 
@@ -83,8 +83,8 @@ bool WebMVideoClient::InitializeConfig(
     if (display_width_ <= 0 || display_height_ <= 0)
       return false;
   } else {
-    MEDIA_LOG(ERROR, log_cb_) << "Unsupported display unit type "
-                              << display_unit_;
+    MEDIA_LOG(ERROR, media_log_) << "Unsupported display unit type "
+                                 << display_unit_;
     return false;
   }
   gfx::Size natural_size = gfx::Size(display_width_, display_height_);
@@ -140,9 +140,9 @@ bool WebMVideoClient::OnUInt(int id, int64 val) {
   }
 
   if (*dst != -1) {
-    MEDIA_LOG(ERROR, log_cb_) << "Multiple values for id " << std::hex << id
-                              << " specified (" << *dst << " and " << val
-                              << ")";
+    MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex << id
+                                 << " specified (" << *dst << " and " << val
+                                 << ")";
     return false;
   }
 
diff --git a/media/formats/webm/webm_video_client.h b/media/formats/webm/webm_video_client.h
index 8e246d9..f2f1df4 100644
--- a/media/formats/webm/webm_video_client.h
+++ b/media/formats/webm/webm_video_client.h
@@ -17,7 +17,7 @@ class VideoDecoderConfig;
 // Helper class used to parse a Video element inside a TrackEntry element.
 class WebMVideoClient : public WebMParserClient {
  public:
-  explicit WebMVideoClient(const LogCB& log_cb);
+  explicit WebMVideoClient(const scoped_refptr<MediaLog>& media_log);
   ~WebMVideoClient() override;
 
   // Reset this object's state so it can process a new video track element.
@@ -41,7 +41,7 @@ class WebMVideoClient : public WebMParserClient {
   bool OnBinary(int id, const uint8* data, int size) override;
   bool OnFloat(int id, double val) override;
 
-  LogCB log_cb_;
+  scoped_refptr<MediaLog> media_log_;
   int64 pixel_width_;
   int64 pixel_height_;
   int64 crop_bottom_;