Deprecate LogCB in favor of using MediaLog

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 76 matching lines @@
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   typedef ChunkDemuxer::InitSegmentReceivedCB InitSegmentReceivedCB;
 
   typedef base::Callback<void(
       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
 
-  SourceState(
-      scoped_ptr<StreamParser> stream_parser,
-      scoped_ptr<FrameProcessor> frame_processor, const LogCB& log_cb,
-      const CreateDemuxerStreamCB& create_demuxer_stream_cb,
-      const scoped_refptr<MediaLog>& media_log);
+  SourceState(scoped_ptr<StreamParser> stream_parser,
+              scoped_ptr<FrameProcessor> frame_processor,
+              const CreateDemuxerStreamCB& create_demuxer_stream_cb,
+              const scoped_refptr<MediaLog>& media_log);
 
   ~SourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::EncryptedMediaInitDataCB&
                 encrypted_media_init_data_cb,
             const NewTextTrackCB& new_text_track_cb);
 
@@ skipping 115 matching lines @@
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
-  LogCB log_cb_;
   scoped_refptr<MediaLog> media_log_;
   StreamParser::InitCB init_cb_;
 
   // During Append(), OnNewConfigs() will trigger the initialization segment
   // received algorithm. This callback is only non-NULL during the lifetime of
   // an Append() call. Note, the MSE spec explicitly disallows this algorithm
   // during an Abort(), since Abort() is allowed only to emit coded frames, and
   // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
   InitSegmentReceivedCB init_segment_received_cb_;
 
   // Indicates that timestampOffset should be updated automatically during
   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
   // changes to MSE spec. See http://crbug.com/371499.
   bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          scoped_ptr<FrameProcessor> frame_processor,
-                         const LogCB& log_cb,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                          const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
       new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
-      log_cb_(log_cb),
       media_log_(media_log),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
 
 SourceState::~SourceState() {
   Shutdown();
 
   STLDeleteValues(&text_stream_map_);
 }
 
 void SourceState::Init(
     const StreamParser::InitCB& init_cb,
     bool allow_audio,
     bool allow_video,
     const StreamParser::EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
     const NewTextTrackCB& new_text_track_cb) {
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
   stream_parser_->Init(
       base::Bind(&SourceState::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&SourceState::OnNewConfigs, base::Unretained(this),
                  allow_audio, allow_video),
       base::Bind(&SourceState::OnNewBuffers, base::Unretained(this)),
       new_text_track_cb_.is_null(), encrypted_media_init_data_cb,
       base::Bind(&SourceState::OnNewMediaSegment, base::Unretained(this)),
       base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
-      log_cb_);
+      media_log_);
 }
 
 void SourceState::SetSequenceMode(bool sequence_mode) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetSequenceMode(sequence_mode);
 }
 
 void SourceState::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
@@ skipping 15 matching lines @@
   DCHECK(init_segment_received_cb_.is_null());
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
   timestamp_offset_during_append_ = timestamp_offset;
   init_segment_received_cb_= init_segment_received_cb;
 
   // TODO(wolenetz/acolwell): Curry and pass a NewBuffersCB here bound with
   // append window and timestamp offset pointer. See http://crbug.com/351454.
   bool result = stream_parser_->Parse(data, length);
   if (!result) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << __FUNCTION__ << ": stream parsing failed."
         << " Data size=" << length
         << " append_window_start=" << append_window_start.InSecondsF()
         << " append_window_end=" << append_window_end.InSecondsF();
   }
   timestamp_offset_during_append_ = NULL;
   init_segment_received_cb_.Reset();
   return result;
 }
 
@@ skipping 217 matching lines @@
   DCHECK(!init_segment_received_cb_.is_null());
 
   if (!audio_config.IsValidConfig() && !video_config.IsValidConfig()) {
     DVLOG(1) << "OnNewConfigs() : Audio & video config are not valid!";
     return false;
   }
 
   // Signal an error if we get configuration info for stream types that weren't
   // specified in AddId() or more configs after a stream is initialized.
   if (allow_audio != audio_config.IsValidConfig()) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << "Initialization segment"
         << (audio_config.IsValidConfig() ? " has" : " does not have")
         << " an audio track, but the mimetype"
         << (allow_audio ? " specifies" : " does not specify")
         << " an audio codec.";
     return false;
   }
 
   if (allow_video != video_config.IsValidConfig()) {
-    MEDIA_LOG(ERROR, log_cb_)
+    MEDIA_LOG(ERROR, media_log_)
         << "Initialization segment"
         << (video_config.IsValidConfig() ? " has" : " does not have")
         << " a video track, but the mimetype"
         << (allow_video ? " specifies" : " does not specify")
         << " a video codec.";
     return false;
   }
 
   bool success = true;
   if (audio_config.IsValidConfig()) {
@@ skipping 14 matching lines @@
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
         DVLOG(1) << "Failed to add audio track to frame processor.";
         return false;
       }
     }
 
     frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
-    success &= audio_->UpdateAudioConfig(audio_config, log_cb_);
+    success &= audio_->UpdateAudioConfig(audio_config, media_log_);
   }
 
   if (video_config.IsValidConfig()) {
     if (!video_) {
       media_log_->SetBooleanProperty("found_video_stream", true);
     }
     if (!video_ ||
         video_->video_decoder_config().codec() != video_config.codec()) {
       media_log_->SetStringProperty("video_codec_name",
                                     video_config.GetHumanReadableCodecName());
     }
 
     if (!video_) {
       video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
 
       if (!video_) {
         DVLOG(1) << "Failed to create a video stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
         DVLOG(1) << "Failed to add video track to frame processor.";
         return false;
       }
     }
 
-    success &= video_->UpdateVideoConfig(video_config, log_cb_);
+    success &= video_->UpdateVideoConfig(video_config, media_log_);
   }
 
   typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
   if (text_stream_map_.empty()) {
     for (TextConfigItr itr = text_configs.begin();
          itr != text_configs.end(); ++itr) {
       ChunkDemuxerStream* const text_stream =
           create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
       if (!frame_processor_->AddTrack(itr->first, text_stream)) {
         success &= false;
-        MEDIA_LOG(ERROR, log_cb_) << "Failed to add text track ID "
-                                  << itr->first << " to frame processor.";
+        MEDIA_LOG(ERROR, media_log_) << "Failed to add text track ID "
+                                     << itr->first << " to frame processor.";
         break;
       }
-      text_stream->UpdateTextConfig(itr->second, log_cb_);
+      text_stream->UpdateTextConfig(itr->second, media_log_);
       text_stream_map_[itr->first] = text_stream;
       new_text_track_cb_.Run(text_stream, itr->second);
     }
   } else {
     const size_t text_count = text_stream_map_.size();
     if (text_configs.size() != text_count) {
       success &= false;
-      MEDIA_LOG(ERROR, log_cb_) << "The number of text track configs changed.";
+      MEDIA_LOG(ERROR, media_log_)
+          << "The number of text track configs changed.";
     } else if (text_count == 1) {
       TextConfigItr config_itr = text_configs.begin();
       TextStreamMap::iterator stream_itr = text_stream_map_.begin();
       ChunkDemuxerStream* text_stream = stream_itr->second;
       TextTrackConfig old_config = text_stream->text_track_config();
       TextTrackConfig new_config(config_itr->second.kind(),
                                  config_itr->second.label(),
                                  config_itr->second.language(),
                                  old_config.id());
       if (!new_config.Matches(old_config)) {
         success &= false;
-        MEDIA_LOG(ERROR, log_cb_)
+        MEDIA_LOG(ERROR, media_log_)
             << "New text track config does not match old one.";
       } else {
         StreamParser::TrackId old_id = stream_itr->first;
         StreamParser::TrackId new_id = config_itr->first;
         if (new_id != old_id) {
           if (frame_processor_->UpdateTrack(old_id, new_id)) {
             text_stream_map_.clear();
             text_stream_map_[config_itr->first] = text_stream;
           } else {
             success &= false;
-            MEDIA_LOG(ERROR, log_cb_)
+            MEDIA_LOG(ERROR, media_log_)
                 << "Error remapping single text track number";
           }
         }
       }
     } else {
       for (TextConfigItr config_itr = text_configs.begin();
            config_itr != text_configs.end(); ++config_itr) {
         TextStreamMap::iterator stream_itr =
             text_stream_map_.find(config_itr->first);
         if (stream_itr == text_stream_map_.end()) {
           success &= false;
-          MEDIA_LOG(ERROR, log_cb_)
+          MEDIA_LOG(ERROR, media_log_)
               << "Unexpected text track configuration for track ID "
               << config_itr->first;
           break;
         }
 
         const TextTrackConfig& new_config = config_itr->second;
         ChunkDemuxerStream* stream = stream_itr->second;
         TextTrackConfig old_config = stream->text_track_config();
         if (!new_config.Matches(old_config)) {
           success &= false;
-          MEDIA_LOG(ERROR, log_cb_) << "New text track config for track ID "
-                                    << config_itr->first
-                                    << " does not match old one.";
+          MEDIA_LOG(ERROR, media_log_) << "New text track config for track ID "
+                                       << config_itr->first
+                                       << " does not match old one.";
           break;
         }
       }
     }
   }
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success)
@@ skipping 189 matching lines @@
   return stream_->GetBufferedDuration();
 }
 
 void ChunkDemuxerStream::OnNewMediaSegment(DecodeTimestamp start_timestamp) {
   DVLOG(2) << "ChunkDemuxerStream::OnNewMediaSegment("
            << start_timestamp.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
   stream_->OnNewMediaSegment(start_timestamp);
 }
 
-bool ChunkDemuxerStream::UpdateAudioConfig(const AudioDecoderConfig& config,
-                                           const LogCB& log_cb) {
+bool ChunkDemuxerStream::UpdateAudioConfig(
+    const AudioDecoderConfig& config,
+    const scoped_refptr<MediaLog>& media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
 
     // On platforms which support splice frames, enable splice frames and
     // partial append window support for most codecs (notably: not opus).
     const bool codec_supported = config.codec() == kCodecMP3 ||
                                  config.codec() == kCodecAAC ||
                                  config.codec() == kCodecVorbis;
     splice_frames_enabled_ = splice_frames_enabled_ && codec_supported;
     partial_append_window_trimming_enabled_ =
         splice_frames_enabled_ && codec_supported;
 
     stream_.reset(
-        new SourceBufferStream(config, log_cb, splice_frames_enabled_));
+        new SourceBufferStream(config, media_log, splice_frames_enabled_));
     return true;
   }
 
   return stream_->UpdateAudioConfig(config);
 }
 
-bool ChunkDemuxerStream::UpdateVideoConfig(const VideoDecoderConfig& config,
-                                           const LogCB& log_cb) {
+bool ChunkDemuxerStream::UpdateVideoConfig(
+    const VideoDecoderConfig& config,
+    const scoped_refptr<MediaLog>& media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, VIDEO);
   base::AutoLock auto_lock(lock_);
 
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
     stream_.reset(
-        new SourceBufferStream(config, log_cb, splice_frames_enabled_));
+        new SourceBufferStream(config, media_log, splice_frames_enabled_));
     return true;
   }
 
   return stream_->UpdateVideoConfig(config);
 }
 
-void ChunkDemuxerStream::UpdateTextConfig(const TextTrackConfig& config,
-                                          const LogCB& log_cb) {
+void ChunkDemuxerStream::UpdateTextConfig(
+    const TextTrackConfig& config,
+    const scoped_refptr<MediaLog>& media_log) {
   DCHECK_EQ(type_, TEXT);
   base::AutoLock auto_lock(lock_);
   DCHECK(!stream_);
   DCHECK_EQ(state_, UNINITIALIZED);
-  stream_.reset(new SourceBufferStream(config, log_cb, splice_frames_enabled_));
+  stream_.reset(
+      new SourceBufferStream(config, media_log, splice_frames_enabled_));
 }
 
 void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->MarkEndOfStream();
 }
 
 void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
@@ skipping 111 matching lines @@
                << type_;
       break;
   }
 
   base::ResetAndReturn(&read_cb_).Run(status, buffer);
 }
 
 ChunkDemuxer::ChunkDemuxer(
     const base::Closure& open_cb,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
-    const LogCB& log_cb,
     const scoped_refptr<MediaLog>& media_log,
     bool splice_frames_enabled)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       encrypted_media_init_data_cb_(encrypted_media_init_data_cb),
       enable_text_(false),
-      log_cb_(log_cb),
       media_log_(media_log),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
       liveness_(DemuxerStream::LIVENESS_UNKNOWN),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!encrypted_media_init_data_cb_.is_null());
 }
 
 std::string ChunkDemuxer::GetDisplayName() const {
@@ skipping 119 matching lines @@
 ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
                                          const std::string& type,
                                          std::vector<std::string>& codecs) {
   base::AutoLock auto_lock(lock_);
 
   if ((state_ != WAITING_FOR_INIT && state_ != INITIALIZING) || IsValidId(id))
     return kReachedIdLimit;
 
   bool has_audio = false;
   bool has_video = false;
-  scoped_ptr<media::StreamParser> stream_parser(
-      StreamParserFactory::Create(type, codecs, log_cb_,
-                                  &has_audio, &has_video));
+  scoped_ptr<media::StreamParser> stream_parser(StreamParserFactory::Create(
+      type, codecs, media_log_, &has_audio, &has_video));
 
   if (!stream_parser)
     return ChunkDemuxer::kNotSupported;
 
   if ((has_audio && !source_id_audio_.empty()) ||
       (has_video && !source_id_video_.empty()))
     return kReachedIdLimit;
 
   if (has_audio)
     source_id_audio_ = id;
 
   if (has_video)
     source_id_video_ = id;
 
   scoped_ptr<FrameProcessor> frame_processor(
       new FrameProcessor(base::Bind(&ChunkDemuxer::IncreaseDurationIfNecessary,
                          base::Unretained(this))));
 
-  scoped_ptr<SourceState> source_state(
-      new SourceState(stream_parser.Pass(),
-                      frame_processor.Pass(), log_cb_,
-                      base::Bind(&ChunkDemuxer::CreateDemuxerStream,
-                                 base::Unretained(this)),
-                      media_log_));
+  scoped_ptr<SourceState> source_state(new SourceState(
+      stream_parser.Pass(), frame_processor.Pass(),
+      base::Bind(&ChunkDemuxer::CreateDemuxerStream, base::Unretained(this)),
+      media_log_));
 
   SourceState::NewTextTrackCB new_text_track_cb;
 
   if (enable_text_) {
     new_text_track_cb = base::Bind(&ChunkDemuxer::OnNewTextTrack,
                                    base::Unretained(this));
   }
 
   source_state->Init(
       base::Bind(&ChunkDemuxer::OnSourceInitDone, base::Unretained(this)),
@@ skipping 362 matching lines @@
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   if (params.duration != TimeDelta() && duration_ == kNoTimestamp())
     UpdateDuration(params.duration);
 
   if (!params.timeline_offset.is_null()) {
     if (!timeline_offset_.is_null() &&
         params.timeline_offset != timeline_offset_) {
-      MEDIA_LOG(ERROR, log_cb_)
+      MEDIA_LOG(ERROR, media_log_)
           << "Timeline offset is not the same across all SourceBuffers.";
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
       return;
     }
 
     timeline_offset_ = params.timeline_offset;
   }
 
   if (params.liveness != DemuxerStream::LIVENESS_UNKNOWN) {
     if (audio_)
@@ skipping 156 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media