Reland: Use GpuMemoryBufferVideoFramePool for WebMediaPlayerMS and MediaStreamVideoRendererSink

content/renderer/media/webmediaplayer_ms.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_ms.h"
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 scoped_refptr<media::VideoFrame> CopyFrameToYV12(
     const scoped_refptr<media::VideoFrame>& frame,
     media::SkCanvasVideoRenderer* video_renderer) {
   const scoped_refptr<media::VideoFrame> new_frame =
       media::VideoFrame::CreateFrame(media::PIXEL_FORMAT_YV12,
                                      frame->coded_size(), frame->visible_rect(),
                                      frame->natural_size(), frame->timestamp());
 
   if (frame->HasTextures()) {
     DCHECK(frame->format() == media::PIXEL_FORMAT_ARGB ||
-           frame->format() == media::PIXEL_FORMAT_XRGB);
+           frame->format() == media::PIXEL_FORMAT_XRGB ||
+           frame->format() == media::PIXEL_FORMAT_I420 ||
+           frame->format() == media::PIXEL_FORMAT_UYVY);
     SkBitmap bitmap;
     bitmap.allocN32Pixels(frame->visible_rect().width(),
                           frame->visible_rect().height());
     SkCanvas canvas(bitmap);
 
     cc::ContextProvider* const provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     if (provider) {
       const media::Context3D context_3d =
           media::Context3D(provider->ContextGL(), provider->GrContext());
@@ skipping 20 matching lines @@
 }
 
 }  // anonymous namespace
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     media::MediaLog* media_log,
     scoped_ptr<MediaStreamRendererFactory> factory,
-    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    const scoped_refptr<base::TaskRunner>& worker_task_runner,
+    const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(0)),
       volume_(1.0f),
       client_(client),
       delegate_(delegate),
       paused_(true),
       received_first_frame_(false),
       media_log_(media_log),
       renderer_factory_(factory.Pass()),
+      media_task_runner_(media_task_runner),
+      worker_task_runner_(worker_task_runner),
+      gpu_factories_(gpu_factories),
       compositor_(new Compositor(compositor_task_runner)),
       compositor_task_runner_(compositor_task_runner) {
   DVLOG(1) << "WebMediaPlayerMS::ctor";
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 WebMediaPlayerMS::~WebMediaPlayerMS() {
   DVLOG(1) << "WebMediaPlayerMS::dtor";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 41 matching lines @@
   uint32 hash_value = base::Hash(url.string().utf8());
   compositor_->SetSerial(((hash_value & 0x7FFFFFFF) << 1) | (remote ? 1 : 0));
 
   SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   SetReadyState(WebMediaPlayer::ReadyStateHaveNothing);
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 
   video_frame_provider_ = renderer_factory_->GetVideoFrameProvider(
       url,
       base::Bind(&WebMediaPlayerMS::OnSourceError, AsWeakPtr()),
-      base::Bind(&WebMediaPlayerMS::OnFrameAvailable, AsWeakPtr()));
+      base::Bind(&WebMediaPlayerMS::OnFrameAvailable, AsWeakPtr()),
+      media_task_runner_,
+      worker_task_runner_,
+      gpu_factories_);
 
   RenderFrame* const frame = RenderFrame::FromWebFrame(frame_);
   audio_renderer_ = renderer_factory_->GetAudioRenderer(
       url, frame->GetRoutingID(), std::string(), url::Origin());
 
   if (!video_frame_provider_ && !audio_renderer_) {
     SetNetworkState(WebMediaPlayer::NetworkStateNetworkError);
     return;
   }
 
@@ skipping 569 matching lines @@
 bool WebMediaPlayerMS::Compositor::GetAlgorithmEnabled() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return !!frame_pool_;
 }
 
 void WebMediaPlayerMS::Compositor::SetSerial(uint32 serial) {
   DCHECK(thread_checker_.CalledOnValidThread());
   serial_ = serial;
 }
 }  // namespace content