media-internals: Differentiate error, info, and debug log messages

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 316 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(log_cb_)
+    MEDIA_LOG(log_cb_, ERROR)
         << __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(log_cb_)
+    MEDIA_LOG(log_cb_, ERROR)
         << "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(log_cb_)
+    MEDIA_LOG(log_cb_, ERROR)
         << "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 52 matching lines @@
   }
 
   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(log_cb_) << "Failed to add text track ID " << itr->first
-                           << " to frame processor.";
+        MEDIA_LOG(log_cb_, ERROR) << "Failed to add text track ID "
+                                  << itr->first << " to frame processor.";
         break;
       }
       text_stream->UpdateTextConfig(itr->second, log_cb_);
       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(log_cb_) << "The number of text track configs changed.";
+      MEDIA_LOG(log_cb_, ERROR) << "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(log_cb_) << "New text track config does not match old one.";
+        MEDIA_LOG(log_cb_, ERROR)
+            << "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(log_cb_) << "Error remapping single text track number";
+            MEDIA_LOG(log_cb_, ERROR)
+                << "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(log_cb_) << "Unexpected text track configuration "
-                                "for track ID "
-                             << config_itr->first;
+          MEDIA_LOG(log_cb_, ERROR)
+              << "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(log_cb_) << "New text track config for track ID "
-                             << config_itr->first
-                             << " does not match old one.";
+          MEDIA_LOG(log_cb_, ERROR) << "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 923 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(log_cb_)
+      MEDIA_LOG(log_cb_, ERROR)
           << "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 (liveness_ != DemuxerStream::LIVENESS_UNKNOWN &&
         params.liveness != liveness_) {
-      MEDIA_LOG(log_cb_)
+      MEDIA_LOG(log_cb_, ERROR)
           << "Liveness is not the same across all SourceBuffers.";
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
       return;
     }
 
     if (liveness_ != params.liveness) {
       liveness_ = params.liveness;
       if (audio_)
         audio_->SetLiveness(liveness_);
       if (video_)
@@ skipping 155 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media