Remove RenderThreadImpl dependencies from WebMediaPlayerImpl.

content/renderer/media/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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/buffered_data_source.h"
 #include "content/renderer/media/crypto/encrypted_media_player_support.h"
-#include "content/renderer/media/render_media_log.h"
 #include "content/renderer/media/texttrack_impl.h"
 #include "content/renderer/media/webaudiosourceprovider_impl.h"
 #include "content/renderer/media/webinbandtexttrack_impl.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_params.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/media/webmediasource_impl.h"
-#include "content/renderer/render_thread_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/filter_collection.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
@@ skipping 89 matching lines @@
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
-    const WebMediaPlayerParams& params)
+    scoped_ptr<WebMediaPlayerParams> params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(AUTO),
       main_task_runner_(base::MessageLoopProxy::current()),
-      media_task_runner_(
-          RenderThreadImpl::current()->GetMediaThreadTaskRunner()),
-      media_log_(new RenderMediaLog()),
+      media_task_runner_(params->media_task_runner()),
+      media_log_(params->media_log()),
       pipeline_(media_task_runner_, media_log_.get()),
       load_type_(LoadTypeURL),
       opaque_(false),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       should_notify_time_changed_(false),
       client_(client),
       delegate_(delegate),
-      defer_load_cb_(params.defer_load_cb()),
-      gpu_factories_(RenderThreadImpl::current()->GetGpuFactories()),
+      defer_load_cb_(params->defer_load_cb()),
+      gpu_factories_(params->gpu_factories()),
       supports_save_(true),
       chunk_demuxer_(NULL),
-      // Threaded compositing isn't enabled universally yet.
-      compositor_task_runner_(
-          RenderThreadImpl::current()->compositor_message_loop_proxy()
-              ? RenderThreadImpl::current()->compositor_message_loop_proxy()
-              : base::MessageLoopProxy::current()),
+      compositor_task_runner_(params->compositor_task_runner()),
       compositor_(new VideoFrameCompositor(
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNaturalSizeChanged),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnOpacityChanged))),
       text_track_index_(0),
-      encrypted_media_support_(EncryptedMediaPlayerSupport::Create(client)) {
+      encrypted_media_support_(params->encrypted_media_player_support().Pass()),
+      audio_hardware_config_(params->audio_hardware_config()) {
   DCHECK(encrypted_media_support_);
 
+  // Threaded compositing isn't enabled universally yet.
+  if (!compositor_task_runner_)
+    compositor_task_runner_ = base::MessageLoopProxy::current();
+
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   // |gpu_factories_| requires that its entry points be called on its
   // |GetTaskRunner()|.  Since |pipeline_| will own decoders created from the
   // factories, require that their message loops are identical.
   DCHECK(!gpu_factories_.get() ||
          (gpu_factories_->GetTaskRunner() == media_task_runner_.get()));
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
-      params.audio_renderer_sink().get()
-          ? params.audio_renderer_sink()
+      params->audio_renderer_sink().get()
+          ? params->audio_renderer_sink()
           : new media::NullAudioSink(media_task_runner_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   client_->setWebLayer(NULL);
 
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
@@ skipping 628 matching lines @@
   media::LogCB log_cb = base::Bind(&LogMediaSourceError, media_log_);
   audio_decoders.push_back(new media::FFmpegAudioDecoder(media_task_runner_,
                                                          log_cb));
   audio_decoders.push_back(new media::OpusAudioDecoder(media_task_runner_));
 
   scoped_ptr<media::AudioRenderer> audio_renderer(new media::AudioRendererImpl(
       media_task_runner_,
       audio_source_provider_.get(),
       audio_decoders.Pass(),
       set_decryptor_ready_cb,
-      RenderThreadImpl::current()->GetAudioHardwareConfig()));
+      audio_hardware_config_));
 
   // Create our video decoders and renderer.
   ScopedVector<media::VideoDecoder> video_decoders;
 
   if (gpu_factories_.get()) {
     video_decoders.push_back(
         new media::GpuVideoDecoder(gpu_factories_, media_log_));
   }
 
 #if !defined(MEDIA_DISABLE_LIBVPX)
@@ skipping 175 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace content