MediaLog: Log selected audio/video decoder name.

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 114 matching lines @@
 
 #define BIND_TO_RENDER_LOOP1(function, arg1) \
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
 static void LogMediaSourceError(const scoped_refptr<MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
+// Note: The log will appear in chrome://media-internals page. Only log info
+// that's worht logging.
+static void LogMediaInfo(const scoped_refptr<MediaLog>& media_log,
+                         const std::string& info) {
+  media_log->AddEvent(media_log->CreateInfoEvent(info));
+}
+
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(BufferedDataSource::AUTO),
       main_task_runner_(base::MessageLoopProxy::current()),
@@ skipping 688 matching lines @@
 
 // TODO(xhwang): Move this to a factory class so that we can create different
 // renderers.
 scoped_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
   SetDecryptorReadyCB set_decryptor_ready_cb =
       encrypted_media_support_->CreateSetDecryptorReadyCB();
 
   // Create our audio decoders and renderer.
   ScopedVector<AudioDecoder> audio_decoders;
 
-  LogCB log_cb = base::Bind(&LogMediaSourceError, media_log_);
-  audio_decoders.push_back(new FFmpegAudioDecoder(media_task_runner_, log_cb));
-  audio_decoders.push_back(new OpusAudioDecoder(media_task_runner_));
+  audio_decoders.push_back(new media::FFmpegAudioDecoder(
+      media_task_runner_, base::Bind(&LogMediaSourceError, media_log_)));
+  audio_decoders.push_back(new media::OpusAudioDecoder(media_task_runner_));
 
   scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       media_task_runner_,
       audio_source_provider_.get(),
       audio_decoders.Pass(),
       set_decryptor_ready_cb,
-      audio_hardware_config_));
+      audio_hardware_config_,
+      base::Bind(&LogMediaInfo, media_log_)));
 
   // Create our video decoders and renderer.
   ScopedVector<VideoDecoder> video_decoders;
 
   if (gpu_factories_.get()) {
     video_decoders.push_back(
         new GpuVideoDecoder(gpu_factories_, media_log_));
   }
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
   video_decoders.push_back(new VpxVideoDecoder(media_task_runner_));
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
   video_decoders.push_back(new FFmpegVideoDecoder(media_task_runner_));
 
   scoped_ptr<VideoRenderer> video_renderer(
       new VideoRendererImpl(
           media_task_runner_,
           video_decoders.Pass(),
           set_decryptor_ready_cb,
           base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
-          true));
+          true,
+          base::Bind(&LogMediaInfo, media_log_)));
 
   // Create renderer.
   return scoped_ptr<Renderer>(new RendererImpl(
       media_task_runner_,
       demuxer_.get(),
       audio_renderer.Pass(),
       video_renderer.Pass()));
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
@@ skipping 140 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace media