Deprecate LogCB in favor of using MediaLog

media/formats/mp4/track_run_iterator.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/mp4/track_run_iterator.h"
 
 #include <algorithm>
 
 #include "media/base/buffers.h"
 #include "media/formats/mp4/rcheck.h"
@@ skipping 63 matching lines @@
   DCHECK((timeb_in_us > 0) || (timea_in_us >= kint64min - timeb_in_us));
   return base::TimeDelta::FromMicroseconds(timea_in_us + timeb_in_us);
 }
 
 DecodeTimestamp DecodeTimestampFromRational(int64 numer, int64 denom) {
   return DecodeTimestamp::FromPresentationTime(
       TimeDeltaFromRational(numer, denom));
 }
 
 TrackRunIterator::TrackRunIterator(const Movie* moov,
-                                   const LogCB& log_cb)
-    : moov_(moov), log_cb_(log_cb), sample_offset_(0) {
+                                   const scoped_refptr<MediaLog>& media_log)
+    : moov_(moov), media_log_(media_log), sample_offset_(0) {
   CHECK(moov);
 }
 
 TrackRunIterator::~TrackRunIterator() {}
 
 static bool PopulateSampleInfo(const TrackExtends& trex,
                                const TrackFragmentHeader& tfhd,
                                const TrackFragmentRun& trun,
                                const int64 edit_list_offset,
                                const uint32 i,
                                SampleInfo* sample_info,
                                const SampleDependsOn sdtp_sample_depends_on,
-                               const LogCB& log_cb) {
+                               const scoped_refptr<MediaLog>& media_log) {
   if (i < trun.sample_sizes.size()) {
     sample_info->size = trun.sample_sizes[i];
   } else if (tfhd.default_sample_size > 0) {
     sample_info->size = tfhd.default_sample_size;
   } else {
     sample_info->size = trex.default_sample_size;
   }
 
   if (i < trun.sample_durations.size()) {
     sample_info->duration = trun.sample_durations[i];
@@ skipping 41 matching lines @@
 
     case kSampleDependsOnOthers:
       sample_info->is_keyframe = false;
       break;
 
     case kSampleDependsOnNoOther:
       sample_info->is_keyframe = true;
       break;
 
     case kSampleDependsOnReserved:
-      MEDIA_LOG(ERROR, log_cb) << "Reserved value used in sample dependency"
-                                  " info.";
+      MEDIA_LOG(ERROR, media_log) << "Reserved value used in sample dependency"
+                                     " info.";
       return false;
   }
   return true;
 }
 
 // In well-structured encrypted media, each track run will be immediately
 // preceded by its auxiliary information; this is the only optimal storage
 // pattern in terms of minimum number of bytes from a serial stream needed to
 // begin playback. It also allows us to optimize caching on memory-constrained
 // architectures, because we can cache the relatively small auxiliary
@@ skipping 125 matching lines @@
             tri.aux_info_total_size += tri.aux_info_sizes[k];
           }
         }
       } else {
         tri.aux_info_start_offset = -1;
         tri.aux_info_total_size = 0;
       }
 
       tri.samples.resize(trun.sample_count);
       for (size_t k = 0; k < trun.sample_count; k++) {
-        if (!PopulateSampleInfo(*trex, traf.header, trun, edit_list_offset,
-                                k, &tri.samples[k],
-                                traf.sdtp.sample_depends_on(k),
-                                log_cb_)) {
+        if (!PopulateSampleInfo(*trex, traf.header, trun, edit_list_offset, k,
+                                &tri.samples[k], traf.sdtp.sample_depends_on(k),
+                                media_log_)) {
           return false;
         }
 
         run_start_dts += tri.samples[k].duration;
 
         if (!is_sample_to_group_valid) {
           // Set group description index to 0 to read encryption information
           // from TrackEncryption Box.
           tri.samples[k].cenc_group_description_index = 0;
           continue;
@@ skipping 191 matching lines @@
   if (is_audio())
     return audio_description().sinf.info.track_encryption;
   return video_description().sinf.info.track_encryption;
 }
 
 scoped_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
   DCHECK(is_encrypted());
 
   if (cenc_info_.empty()) {
     DCHECK_EQ(0, aux_info_size());
-    MEDIA_LOG(ERROR, log_cb_) << "Aux Info is not available.";
+    MEDIA_LOG(ERROR, media_log_) << "Aux Info is not available.";
     return scoped_ptr<DecryptConfig>();
   }
 
   size_t sample_idx = sample_itr_ - run_itr_->samples.begin();
   DCHECK_LT(sample_idx, cenc_info_.size());
   const FrameCENCInfo& cenc_info = cenc_info_[sample_idx];
 
   size_t total_size = 0;
   if (!cenc_info.subsamples.empty() &&
       (!cenc_info.GetTotalSizeOfSubsamples(&total_size) ||
        total_size != static_cast<size_t>(sample_size()))) {
-    MEDIA_LOG(ERROR, log_cb_) << "Incorrect CENC subsample size.";
+    MEDIA_LOG(ERROR, media_log_) << "Incorrect CENC subsample size.";
     return scoped_ptr<DecryptConfig>();
   }
 
   const std::vector<uint8>& kid = GetKeyId(sample_idx);
   return scoped_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(&kid[0]), kid.size()),
       std::string(reinterpret_cast<const char*>(cenc_info.iv),
                   arraysize(cenc_info.iv)),
       cenc_info.subsamples));
 }
@@ skipping 28 matching lines @@
 }
 
 uint8 TrackRunIterator::GetIvSize(size_t sample_index) const {
   uint32 index = GetGroupDescriptionIndex(sample_index);
   return (index == 0) ? track_encryption().default_iv_size
                       : GetSampleEncryptionInfoEntry(index).iv_size;
 }
 
 }  // namespace mp4
 }  // namespace media