Use a shared thread for media operations.

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 <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 110 matching lines @@
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       main_loop_(base::MessageLoopProxy::current()),
-      media_thread_("MediaPipeline"),
+      media_loop_(params.message_loop_proxy()),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0f),
       pending_seek_(false),
       pending_seek_seconds_(0.0f),
       client_(client),
       delegate_(delegate),
       media_log_(params.media_log()),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       gpu_factories_(params.gpu_factories()),
       is_local_source_(false),
       supports_save_(true),
       starting_(false),
       chunk_demuxer_(NULL),
       pending_repaint_(false),
       pending_size_change_(false),
       video_frame_provider_client_(NULL) {
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
-  CHECK(media_thread_.Start());
-  pipeline_.reset(new media::Pipeline(
-      media_thread_.message_loop_proxy(), media_log_));
+  pipeline_.reset(new media::Pipeline(media_loop_, media_log_));
 
   // Let V8 know we started new thread if we did not do 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.
   main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&WebMediaPlayerImpl::IncrementExternallyAllocatedMemory,
                  AsWeakPtr()));
 
   // Also we want to be notified of |main_loop_| destruction.
   base::MessageLoop::current()->AddDestructionObserver(this);
 
   if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
     decryptor_.reset(new ProxyDecryptor(
         client,
         frame,
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyAdded),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage),
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnNeedKey)));
   }
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink() ? params.audio_renderer_sink() :
-      new media::NullAudioSink(media_thread_.message_loop_proxy()));
+      new media::NullAudioSink(media_loop_));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
 
   DCHECK(main_loop_->BelongsToCurrentThread());
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
@@ skipping 870 matching lines @@
 void WebMediaPlayerImpl::StartPipeline(WebKit::WebMediaSource* media_source) {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
 
   // Figure out which demuxer to use.
   if (!media_source) {
     DCHECK(!chunk_demuxer_);
     DCHECK(data_source_);
 
     demuxer_.reset(new media::FFmpegDemuxer(
-        media_thread_.message_loop_proxy(), data_source_.get(),
+        media_loop_, data_source_.get(),
         BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", "")));
   } else {
     DCHECK(!chunk_demuxer_);
     DCHECK(!data_source_);
 
     scoped_ptr<WebKit::WebMediaSource> ms(media_source);
     chunk_demuxer_ = new media::ChunkDemuxer(
         BIND_TO_RENDER_LOOP_1(&WebMediaPlayerImpl::OnDemuxerOpened,
                               base::Passed(&ms)),
         BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""),
@@ skipping 11 matching lines @@
 
   // Figure out if EME is enabled.
   media::SetDecryptorReadyCB set_decryptor_ready_cb;
   if (decryptor_) {
     set_decryptor_ready_cb = base::Bind(&ProxyDecryptor::SetDecryptorReadyCB,
                                         base::Unretained(decryptor_.get()));
   }
 
   // Create our audio decoders and renderer.
   ScopedVector<media::AudioDecoder> audio_decoders;
-  audio_decoders.push_back(new media::FFmpegAudioDecoder(
-      media_thread_.message_loop_proxy()));
+  audio_decoders.push_back(new media::FFmpegAudioDecoder(media_loop_));
   if (cmd_line->HasSwitch(switches::kEnableOpusPlayback)) {
-    audio_decoders.push_back(new media::OpusAudioDecoder(
-        media_thread_.message_loop_proxy()));
+    audio_decoders.push_back(new media::OpusAudioDecoder(media_loop_));
   }
 
   scoped_ptr<media::AudioRenderer> audio_renderer(
-      new media::AudioRendererImpl(media_thread_.message_loop_proxy(),
+      new media::AudioRendererImpl(media_loop_,
                                    audio_source_provider_,
                                    audio_decoders.Pass(),
                                    set_decryptor_ready_cb));
   filter_collection->SetAudioRenderer(audio_renderer.Pass());
 
   // Create our video decoders and renderer.
   ScopedVector<media::VideoDecoder> video_decoders;
 
   if (gpu_factories_) {
     video_decoders.push_back(new media::GpuVideoDecoder(
-        media_thread_.message_loop_proxy(), gpu_factories_));
+        media_loop_, gpu_factories_));
   }
 
   // TODO(phajdan.jr): Remove ifdefs when libvpx with vp9 support is released
   // (http://crbug.com/174287) .
 #if !defined(MEDIA_DISABLE_LIBVPX)
   if (cmd_line->HasSwitch(switches::kEnableVp9Playback) ||
       cmd_line->HasSwitch(switches::kEnableVp8AlphaPlayback)) {
-    video_decoders.push_back(new media::VpxVideoDecoder(
-        media_thread_.message_loop_proxy()));
+    video_decoders.push_back(new media::VpxVideoDecoder(media_loop_));
   }
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
-  video_decoders.push_back(new media::FFmpegVideoDecoder(
-      media_thread_.message_loop_proxy()));
+  video_decoders.push_back(new media::FFmpegVideoDecoder(media_loop_));
 
   scoped_ptr<media::VideoRenderer> video_renderer(
       new media::VideoRendererBase(
-          media_thread_.message_loop_proxy(),
+          media_loop_,
           video_decoders.Pass(),
           set_decryptor_ready_cb,
           base::Bind(&WebMediaPlayerImpl::FrameReady, base::Unretained(this)),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::SetOpaque),
           true));
   filter_collection->SetVideoRenderer(video_renderer.Pass());
 
   // ... and we're ready to go!
   starting_ = true;
   pipeline_->Start(
@@ skipping 49 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;
   }
 
-  media_thread_.Stop();
-
   // Release any final references now that everything has stopped.
   pipeline_.reset();
   demuxer_.reset();
   data_source_.reset();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(client_);
   return client_;
@@ skipping 41 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media