Deprecate LogCB in favor of using MediaLog

media/formats/mpeg/mpeg1_audio_stream_parser.cc

 // Copyright 2014 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/formats/mpeg/mpeg1_audio_stream_parser.h"
 
 namespace media {
 
 static const uint32 kMPEG1StartCodeMask = 0xffe00000;
 
@@ skipping 69 matching lines @@
 static const int kXingHeaderMap[2][2] = {{32, 17}, {17, 9}};
 
 // Frame header field constants.
 static const int kBitrateFree = 0;
 static const int kBitrateBad = 0xf;
 static const int kSampleRateReserved = 3;
 static const int kCodecDelay = 529;
 
 // static
 bool MPEG1AudioStreamParser::ParseHeader(
-    const LogCB& log_cb,
+    const scoped_refptr<MediaLog>& media_log,
     const uint8* data,
     Header* header) {
   BitReader reader(data, kHeaderSize);
   int sync;
   int version;
   int layer;
   int is_protected;
   int bitrate_index;
   int sample_rate_index;
   int has_padding;
@@ skipping 20 matching lines @@
            << " layer 0x" << layer
            << " bitrate_index 0x" << bitrate_index
            << " sample_rate_index 0x" << sample_rate_index
            << " channel_mode 0x" << channel_mode;
 
   if (sync != 0x7ff ||
       version == kVersionReserved ||
       layer == kLayerReserved ||
       bitrate_index == kBitrateFree || bitrate_index == kBitrateBad ||
       sample_rate_index == kSampleRateReserved) {
-    MEDIA_LOG(ERROR, log_cb)
+    MEDIA_LOG(ERROR, media_log)
         << "Invalid header data :" << std::hex << " sync 0x" << sync
         << " version 0x" << version << " layer 0x" << layer
         << " bitrate_index 0x" << bitrate_index << " sample_rate_index 0x"
         << sample_rate_index << " channel_mode 0x" << channel_mode;
     return false;
   }
 
   if (layer == kLayer2 && kIsAllowed[bitrate_index][channel_mode]) {
-    MEDIA_LOG(ERROR, log_cb) << "Invalid (bitrate_index, channel_mode)"
-                             << " combination :" << std::hex
-                             << " bitrate_index " << bitrate_index
-                             << " channel_mode " << channel_mode;
+    MEDIA_LOG(ERROR, media_log) << "Invalid (bitrate_index, channel_mode)"
+                                << " combination :" << std::hex
+                                << " bitrate_index " << bitrate_index
+                                << " channel_mode " << channel_mode;
     return false;
   }
 
   int bitrate = kBitrateMap[bitrate_index][kVersionLayerMap[version][layer]];
 
   if (bitrate == 0) {
-    MEDIA_LOG(ERROR, log_cb) << "Invalid bitrate :" << std::hex << " version "
-                             << version << " layer " << layer
-                             << " bitrate_index " << bitrate_index;
+    MEDIA_LOG(ERROR, media_log) << "Invalid bitrate :" << std::hex
+                                << " version " << version << " layer " << layer
+                                << " bitrate_index " << bitrate_index;
     return false;
   }
 
   DVLOG(2) << " bitrate " << bitrate;
 
   int frame_sample_rate = kSampleRateMap[sample_rate_index][version];
   if (frame_sample_rate == 0) {
-    MEDIA_LOG(ERROR, log_cb) << "Invalid sample rate :" << std::hex
-                             << " version " << version << " sample_rate_index "
-                             << sample_rate_index;
+    MEDIA_LOG(ERROR, media_log) << "Invalid sample rate :" << std::hex
+                                << " version " << version
+                                << " sample_rate_index " << sample_rate_index;
     return false;
   }
   header->sample_rate = frame_sample_rate;
 
   // http://teslabs.com/openplayer/docs/docs/specs/mp3_structure2.pdf
   // Table 2.1.5
   int samples_per_frame;
   switch (layer) {
     case kLayer1:
       samples_per_frame = 384;
@@ skipping 56 matching lines @@
                                              int* sample_count,
                                              bool* metadata_frame) const {
   DCHECK(data);
   DCHECK_GE(size, 0);
   DCHECK(frame_size);
 
   if (size < kHeaderSize)
     return 0;
 
   Header header;
-  if (!ParseHeader(log_cb(), data, &header))
+  if (!ParseHeader(media_log(), data, &header))
     return -1;
 
   *frame_size = header.frame_size;
   if (sample_rate)
     *sample_rate = header.sample_rate;
   if (sample_count)
     *sample_count = header.sample_count;
   if (channel_layout)
     *channel_layout = header.channel_layout;
   if (metadata_frame)
@@ skipping 18 matching lines @@
   // If we don't have enough data available to check, return 0 so frame parsing
   // will be retried once more data is available.
   BitReader reader(data + header_bytes_read, size - header_bytes_read);
   if (!reader.SkipBits(xing_header_index * 8) ||
       !reader.ReadBits(sizeof(tag) * 8, &tag)) {
     return 0;
   }
 
   // Check to see if the tag contains 'Xing' or 'Info'
   if (tag == 0x496e666f || tag == 0x58696e67) {
-    MEDIA_LOG(DEBUG, log_cb()) << "Skipping XING header.";
+    MEDIA_LOG(DEBUG, media_log()) << "Skipping XING header.";
     if (metadata_frame)
       *metadata_frame = true;
     return header_bytes_read + reader.bits_read() / 8;
   }
 
   // If it wasn't a XING frame, just return the number consumed bytes.
   return header_bytes_read;
 }
 
 }  // namespace media