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

media/mojo/services/mojo_renderer_service.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/mojo/services/mojo_renderer_service.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_log.h"
 #include "media/base/video_renderer.h"
 #include "media/mojo/services/demuxer_stream_provider_shim.h"
 #include "media/mojo/services/renderer_config.h"
 #include "media/renderers/audio_renderer_impl.h"
 #include "media/renderers/renderer_impl.h"
 #include "media/renderers/video_renderer_impl.h"
 
 namespace media {
 
 // Time interval to update media time.
 const int kTimeUpdateIntervalMs = 50;
 
-static void LogMediaSourceError(const scoped_refptr<MediaLog>& media_log,
-                                const std::string& error) {
-  media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
+static void AddLogEntry(const scoped_refptr<MediaLog>& media_log,
+                        MediaLog::MediaLogLevel level,
+                        const std::string& message) {
+  media_log->AddEvent(media_log->CreateLogEvent(level, message));

[DaleCurtis, 2015/03/31 00:12:26]

Separately from this CL, I wonder if we should just have AddEvent(level,
message) instead of every location needing to call CreateLogEvent too.

[wolenetz, 2015/03/31 00:30:11]

sgtm. I'll put something together after this CL to do that, though would
probably call it "AddLogEvent(level, message)" to reduce confusion with the
virtual AddEvent() interface that would need to remain (and that it would use).

 }
 
 static void PaintNothing(const scoped_refptr<VideoFrame>& frame) {
 }
 
 MojoRendererService::MojoRendererService()
     : state_(STATE_UNINITIALIZED),
       last_media_time_usec_(0),
       weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
   DVLOG(1) << __FUNCTION__;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner(
       base::MessageLoop::current()->task_runner());
   scoped_refptr<MediaLog> media_log(new MediaLog());
   RendererConfig* renderer_config = RendererConfig::Get();
   audio_renderer_sink_ = renderer_config->GetAudioRendererSink();
 
   scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       task_runner, audio_renderer_sink_.get(),
       renderer_config->GetAudioDecoders(
                            task_runner,
-                           base::Bind(&LogMediaSourceError, media_log)).Pass(),
+                           base::Bind(&AddLogEntry, media_log)).Pass(),
       renderer_config->GetAudioHardwareConfig(), media_log));
 
   scoped_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
       task_runner,
       renderer_config->GetVideoDecoders(
                            task_runner,
-                           base::Bind(&LogMediaSourceError, media_log)).Pass(),
+                           base::Bind(&AddLogEntry, media_log)).Pass(),
       true, media_log));
 
   // Create renderer.
   renderer_.reset(new RendererImpl(
       task_runner, audio_renderer.Pass(), video_renderer.Pass()));
 }
 
 MojoRendererService::~MojoRendererService() {
 }
 
@@ skipping 115 matching lines @@
 }
 
 void MojoRendererService::OnFlushCompleted(const mojo::Closure& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, STATE_FLUSHING);
   state_ = STATE_PLAYING;
   callback.Run();
 }
 
 }  // namespace media