Deprecate LogCB in favor of using MediaLog

media/filters/source_buffer_stream.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/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
@@ skipping 76 matching lines @@
       return SourceBufferRange::NO_GAPS_ALLOWED;
     case SourceBufferStream::kText:
       return SourceBufferRange::ALLOW_GAPS;
   }
 
   NOTREACHED();
   return SourceBufferRange::NO_GAPS_ALLOWED;
 }
 
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config,
-                                       const LogCB& log_cb,
+                                       const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
-    : log_cb_(log_cb),
+    : media_log_(media_log),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoDecodeTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoDecodeTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kSourceBufferAudioMemoryLimit),
       config_change_pending_(false),
       splice_buffers_index_(0),
       pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
-                                       const LogCB& log_cb,
+                                       const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
-    : log_cb_(log_cb),
+    : media_log_(media_log),
       current_config_index_(0),
       append_config_index_(0),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
       last_appended_buffer_timestamp_(kNoDecodeTimestamp()),
       last_appended_buffer_is_keyframe_(false),
       last_output_buffer_timestamp_(kNoDecodeTimestamp()),
       max_interbuffer_distance_(kNoTimestamp()),
       memory_limit_(kSourceBufferVideoMemoryLimit),
       config_change_pending_(false),
       splice_buffers_index_(0),
       pending_buffers_complete_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config,
-                                       const LogCB& log_cb,
+                                       const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
-    : log_cb_(log_cb),
+    : media_log_(media_log),
       current_config_index_(0),
       append_config_index_(0),
       text_track_config_(text_config),
       seek_pending_(false),
       end_of_stream_(false),
       seek_buffer_timestamp_(kNoTimestamp()),
       selected_range_(NULL),
       media_segment_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       new_media_segment_(false),
@@ skipping 54 matching lines @@
   DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName() << ": buffers dts=["
            << buffers.front()->GetDecodeTimestamp().InSecondsF() << ";"
            << buffers.back()->GetDecodeTimestamp().InSecondsF() << "] pts=["
            << buffers.front()->timestamp().InSecondsF() << ";"
            << buffers.back()->timestamp().InSecondsF() << "(last frame dur="
            << buffers.back()->duration().InSecondsF() << ")]";
 
   // New media segments must begin with a keyframe.
   // TODO(wolenetz): Relax this requirement. See http://crbug.com/229412.
   if (new_media_segment_ && !buffers.front()->is_key_frame()) {
-    MEDIA_LOG(ERROR, log_cb_) << "Media segment did not begin with key frame.";
+    MEDIA_LOG(ERROR, media_log_)
+        << "Media segment did not begin with key frame.";
     return false;
   }
 
   // Buffers within a media segment should be monotonically increasing.
   if (!IsMonotonicallyIncreasing(buffers))
     return false;
 
   if (media_segment_start_time_ < DecodeTimestamp() ||
       buffers.front()->GetDecodeTimestamp() < DecodeTimestamp()) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << "Cannot append a media segment with negative timestamps.";
     return false;
   }
 
   if (!IsNextTimestampValid(buffers.front()->GetDecodeTimestamp(),
                             buffers.front()->is_key_frame())) {
     const DecodeTimestamp& dts = buffers.front()->GetDecodeTimestamp();
-    MEDIA_LOG(ERROR, log_cb_) << "Invalid same timestamp construct detected at"
-                              << " time " << dts.InSecondsF();
+    MEDIA_LOG(ERROR, media_log_)
+        << "Invalid same timestamp construct detected at"
+        << " time " << dts.InSecondsF();
 
     return false;
   }
 
   UpdateMaxInterbufferDistance(buffers);
   SetConfigIds(buffers);
 
   // Save a snapshot of stream state before range modifications are made.
   DecodeTimestamp next_buffer_timestamp = GetNextBufferTimestamp();
   BufferQueue deleted_buffers;
@@ skipping 267 matching lines @@
     bool current_is_keyframe = (*itr)->is_key_frame();
     DCHECK(current_timestamp != kNoDecodeTimestamp());
     DCHECK((*itr)->duration() >= base::TimeDelta())
         << "Packet with invalid duration."
         << " pts " << (*itr)->timestamp().InSecondsF()
         << " dts " << (*itr)->GetDecodeTimestamp().InSecondsF()
         << " dur " << (*itr)->duration().InSecondsF();
 
     if (prev_timestamp != kNoDecodeTimestamp()) {
       if (current_timestamp < prev_timestamp) {
-        MEDIA_LOG(ERROR, log_cb_) << "Buffers did not monotonically increase.";
+        MEDIA_LOG(ERROR, media_log_)
+            << "Buffers did not monotonically increase.";
         return false;
       }
 
       if (current_timestamp == prev_timestamp &&
           !SourceBufferRange::AllowSameTimestamp(prev_is_keyframe,
                                                  current_is_keyframe)) {
-        MEDIA_LOG(ERROR, log_cb_) << "Unexpected combination of buffers with"
-                                  << " the same timestamp detected at "
-                                  << current_timestamp.InSecondsF();
+        MEDIA_LOG(ERROR, media_log_) << "Unexpected combination of buffers with"
+                                     << " the same timestamp detected at "
+                                     << current_timestamp.InSecondsF();
         return false;
       }
     }
 
     prev_timestamp = current_timestamp;
     prev_is_keyframe = current_is_keyframe;
   }
   return true;
 }
 
@@ skipping 706 matching lines @@
     return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
   return max_interbuffer_distance_;
 }
 
 bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(!audio_configs_.empty());
   DCHECK(video_configs_.empty());
   DVLOG(3) << "UpdateAudioConfig.";
 
   if (audio_configs_[0].codec() != config.codec()) {
-    MEDIA_LOG(ERROR, log_cb_) << "Audio codec changes not allowed.";
+    MEDIA_LOG(ERROR, media_log_) << "Audio codec changes not allowed.";
     return false;
   }
 
   if (audio_configs_[0].is_encrypted() != config.is_encrypted()) {
-    MEDIA_LOG(ERROR, log_cb_) << "Audio encryption changes not allowed.";
+    MEDIA_LOG(ERROR, media_log_) << "Audio encryption changes not allowed.";
     return false;
   }
 
   // Check to see if the new config matches an existing one.
   for (size_t i = 0; i < audio_configs_.size(); ++i) {
     if (config.Matches(audio_configs_[i])) {
       append_config_index_ = i;
       return true;
     }
   }
 
   // No matches found so let's add this one to the list.
   append_config_index_ = audio_configs_.size();
   DVLOG(2) << "New audio config - index: " << append_config_index_;
   audio_configs_.resize(audio_configs_.size() + 1);
   audio_configs_[append_config_index_] = config;
   return true;
 }
 
 bool SourceBufferStream::UpdateVideoConfig(const VideoDecoderConfig& config) {
   DCHECK(!video_configs_.empty());
   DCHECK(audio_configs_.empty());
   DVLOG(3) << "UpdateVideoConfig.";
 
   if (video_configs_[0].codec() != config.codec()) {
-    MEDIA_LOG(ERROR, log_cb_) << "Video codec changes not allowed.";
+    MEDIA_LOG(ERROR, media_log_) << "Video codec changes not allowed.";
     return false;
   }
 
   if (video_configs_[0].is_encrypted() != config.is_encrypted()) {
-    MEDIA_LOG(ERROR, log_cb_) << "Video encryption changes not allowed.";
+    MEDIA_LOG(ERROR, media_log_) << "Video encryption changes not allowed.";
     return false;
   }
 
   // Check to see if the new config matches an existing one.
   for (size_t i = 0; i < video_configs_.size(); ++i) {
     if (config.Matches(video_configs_[i])) {
       append_config_index_ = i;
       return true;
     }
   }
@@ skipping 284 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media