Vanquish the remnants of media::MessageLoopFactory.

webkit/media/webmediaplayer_impl.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 "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 104 matching lines @@
 // are really necessary.
 typedef base::Callback<void(const std::string&,
                             const std::string&,
                             scoped_array<uint8>,
                             int)> OnNeedKeyCB;
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
-    media::FilterCollection* collection,
     WebKit::WebAudioSourceProvider* audio_source_provider,
     media::AudioRendererSink* audio_renderer_sink,
-    media::MessageLoopFactory* message_loop_factory,
+    const scoped_refptr<media::GpuVideoDecoder::Factories>& gpu_factories,
     MediaStreamClient* media_stream_client,
     media::MediaLog* media_log)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       main_loop_(MessageLoop::current()),
-      filter_collection_(collection),
-      message_loop_factory_(message_loop_factory),
+      filter_collection_(new media::FilterCollection()),
+      media_thread_("MediaPipeline"),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       client_(client),
       proxy_(new WebMediaPlayerProxy(main_loop_->message_loop_proxy(), this)),
       delegate_(delegate),
       media_stream_client_(media_stream_client),
       media_log_(media_log),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       audio_source_provider_(audio_source_provider),
       audio_renderer_sink_(audio_renderer_sink),
       is_local_source_(false),
       supports_save_(true),
       starting_(false) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
-  scoped_refptr<base::MessageLoopProxy> pipeline_message_loop =
-      message_loop_factory_->GetMessageLoop(
-          media::MessageLoopFactory::kPipeline);
-  pipeline_ = new media::Pipeline(pipeline_message_loop, media_log_);
+  CHECK(media_thread_.Start());
+  pipeline_ = new media::Pipeline(
+      media_thread_.message_loop_proxy(), media_log_);
+
+  decryptor_.reset(new ProxyDecryptor(
+      media_thread_.message_loop_proxy(), proxy_.get(), client, frame));
 
   // Let V8 know we started new thread if we did not did it yet.
   // Made separate task to avoid deletion of player currently being created.
   // Also, delaying GC until after player starts gets rid of starting lag --
   // collection happens in parallel with playing.
   //
   // TODO(enal): remove when we get rid of per-audio-stream thread.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
   main_loop_->AddDestructionObserver(this);
 
+  // Create the GPU video decoder if factories were provided.
+  if (gpu_factories) {
+    filter_collection_->GetVideoDecoders()->push_back(
+        new media::GpuVideoDecoder(
+            media_thread_.message_loop_proxy(),
+            gpu_factories));
+  }
+
   // Create default video renderer.
   scoped_refptr<media::VideoRendererBase> video_renderer =
       new media::VideoRendererBase(
-          pipeline_message_loop,
+          media_thread_.message_loop_proxy(),
           base::Bind(&WebMediaPlayerProxy::Repaint, proxy_),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetOpaque),
           true);
   filter_collection_->AddVideoRenderer(video_renderer);
   proxy_->set_frame_provider(video_renderer);
 
-  // Create default audio renderer.
+  // Create default audio renderer using the null sink if no sink was provided.
+  if (!audio_renderer_sink) {

[acolwell GONE FROM CHROMIUM, 2012/12/10 18:12:16]

Why are these audio changes included in this CL?

+    audio_renderer_sink = new media::NullAudioSink();
+  }
   filter_collection_->AddAudioRenderer(
-      new media::AudioRendererImpl(new media::NullAudioSink()));
+      new media::AudioRendererImpl(audio_renderer_sink));
 
   if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
-    decryptor_.reset(new ProxyDecryptor(message_loop_factory_->GetMessageLoop(
-        media::MessageLoopFactory::kPipeline), proxy_.get(), client, frame));
+    decryptor_.reset(new ProxyDecryptor(
+        media_thread_.message_loop_proxy(), proxy_.get(), client, frame));
   }
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
@@ skipping 47 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(gurl), kMaxURLScheme);
 
   // Handle any volume/preload changes that occured before load().
   setVolume(GetClient()->volume());
   setPreload(GetClient()->preload());
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
-  scoped_refptr<base::MessageLoopProxy> message_loop =
-      message_loop_factory_->GetMessageLoop(
-          media::MessageLoopFactory::kPipeline);
-
   // Media streams pipelines can start immediately.
   if (BuildMediaStreamCollection(url, media_stream_client_,
-                                 message_loop,
+                                 media_thread_.message_loop_proxy(),
                                  filter_collection_.get())) {
     supports_save_ = false;
     StartPipeline();
     return;
   }
 
   // Media source pipelines can start immediately.
   if (!url.isEmpty() && url == GetClient()->sourceURL()) {
     chunk_demuxer_ = new media::ChunkDemuxer(
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
         BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""));
 
     BuildMediaSourceCollection(chunk_demuxer_,
-                               message_loop,
+                               media_thread_.message_loop_proxy(),
                                filter_collection_.get(),
                                decryptor_.get());
     supports_save_ = false;
     StartPipeline();
     return;
   }
 
   // Otherwise it's a regular request which requires resolving the URL first.
   proxy_->set_data_source(
       new BufferedDataSource(main_loop_, frame_, media_log_,
                              base::Bind(&WebMediaPlayerImpl::NotifyDownloading,
                                         AsWeakPtr())));
   proxy_->data_source()->Initialize(
       url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
       base::Bind(
           &WebMediaPlayerImpl::DataSourceInitialized,
           AsWeakPtr(), gurl));
 
   is_local_source_ = !gurl.SchemeIs("http") && !gurl.SchemeIs("https");
 
   BuildDefaultCollection(proxy_->data_source(),
-                         message_loop,
+                         media_thread_.message_loop_proxy(),
                          filter_collection_.get(),
                          decryptor_.get());
 }
 
 void WebMediaPlayerImpl::cancelLoad() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 }
 
 void WebMediaPlayerImpl::play() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
@@ skipping 490 matching lines @@
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   DVLOG(1) << "generateKeyRequest: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(init_data),
                           static_cast<size_t>(init_data_length));
 
   // TODO(xhwang): We assume all streams are from the same container (thus have
   // the same "type") for now. In the future, the "type" should be passed down
   // from the application.
   if (!decryptor_->GenerateKeyRequest(key_system.utf8(),
-                                     init_data_type_,
-                                     init_data, init_data_length)) {
+                                      init_data_type_,
+                                      init_data, init_data_length)) {
     current_key_system_.reset();
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::addKey(
     const WebString& key_system,
     const unsigned char* key,
@@ skipping 25 matching lines @@
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   DVLOG(1) << "addKey: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(key),
                           static_cast<size_t>(key_length)) << ", "
            << std::string(reinterpret_cast<const char*>(init_data),
                           static_cast<size_t>(init_data_length))
            << " [" << session_id.utf8().data() << "]";
 
   decryptor_->AddKey(key_system.utf8(), key, key_length,
-                    init_data, init_data_length, session_id.utf8());
+                     init_data, init_data_length, session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::cancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
   WebMediaPlayer::MediaKeyException e =
       CancelKeyRequestInternal(key_system, session_id);
   ReportMediaKeyExceptionToUMA("cancelKeyRequest", key_system, e);
   return e;
@@ skipping 302 matching lines @@
   pipeline_->Stop(base::Bind(
       &base::WaitableEvent::Signal, base::Unretained(&waiter)));
   waiter.Wait();
 
   // Let V8 know we are not using extra resources anymore.
   if (incremented_externally_allocated_memory_) {
     v8::V8::AdjustAmountOfExternalAllocatedMemory(-kPlayerExtraMemory);
     incremented_externally_allocated_memory_ = false;
   }
 
-  message_loop_factory_.reset();
+  media_thread_.Stop();
 
   // And then detach the proxy, it may live on the render thread for a little
   // longer until all the tasks are finished.
   if (proxy_) {
     proxy_->Detach();
     proxy_ = NULL;
   }
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   DCHECK(client_);
   return client_;
 }
 
 WebKit::WebAudioSourceProvider* WebMediaPlayerImpl::audioSourceProvider() {
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media