Relanding 1143663007: VideoFrame: Separate Pixel Format from Storage Type.

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 "base/bind.h"
 #include "base/callback.h"
@@ skipping 25 matching lines @@
 
 using blink::WebCanvas;
 using blink::WebMediaPlayer;
 using blink::WebRect;
 using blink::WebSize;
 
 namespace content {
 
 namespace {
 
-// This function copies a YV12 or NATIVE_TEXTURE to a new YV12
-// media::VideoFrame.
+// This function copies |frame| to a new YV12 media::VideoFrame.
 scoped_refptr<media::VideoFrame> CopyFrameToYV12(
     const scoped_refptr<media::VideoFrame>& frame,
     media::SkCanvasVideoRenderer* video_renderer) {
-  DCHECK(frame->format() == media::VideoFrame::YV12 ||
-         frame->format() == media::VideoFrame::I420 ||
-         frame->format() == media::VideoFrame::NATIVE_TEXTURE);
   scoped_refptr<media::VideoFrame> new_frame =
       media::VideoFrame::CreateFrame(media::VideoFrame::YV12,
                                      frame->coded_size(),
                                      frame->visible_rect(),
                                      frame->natural_size(),
                                      frame->timestamp());
 
-  if (frame->format() == media::VideoFrame::NATIVE_TEXTURE) {
+  if (frame->storage_type() == media::VideoFrame::STORAGE_TEXTURE) {
+    DCHECK(frame->format() == media::VideoFrame::ARGB ||
+           frame->format() == media::VideoFrame::XRGB);
     SkBitmap bitmap;
     bitmap.allocN32Pixels(frame->visible_rect().width(),
                           frame->visible_rect().height());
     SkCanvas canvas(bitmap);
 
-    cc::ContextProvider* provider =
+    cc::ContextProvider* const provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     if (provider) {
-      media::Context3D context_3d =
+      const media::Context3D context_3d =
           media::Context3D(provider->ContextGL(), provider->GrContext());
       DCHECK(context_3d.gl);
       video_renderer->Copy(frame.get(), &canvas, context_3d);
     } else {
       // GPU Process crashed.
       bitmap.eraseColor(SK_ColorTRANSPARENT);
     }
-    media::CopyRGBToVideoFrame(
-        reinterpret_cast<uint8*>(bitmap.getPixels()),
-        bitmap.rowBytes(),
-        frame->visible_rect(),
-        new_frame.get());
+    media::CopyRGBToVideoFrame(reinterpret_cast<uint8*>(bitmap.getPixels()),
+                               bitmap.rowBytes(),
+                               frame->visible_rect(),
+                               new_frame.get());
   } else {
-    size_t number_of_planes =
-        media::VideoFrame::NumPlanes(frame->format());
-    for (size_t i = 0; i < number_of_planes; ++i) {
+    DCHECK(media::VideoFrame::IsMappable(frame->storage_type()));
+    DCHECK(frame->format() == media::VideoFrame::YV12 ||
+           frame->format() == media::VideoFrame::I420);
+    for (size_t i = 0; i < media::VideoFrame::NumPlanes(frame->format()); ++i) {
       media::CopyPlane(i, frame->data(i), frame->stride(i),
                        frame->rows(i), new_frame.get());
     }
   }
   return new_frame;
 }
 
 }  // anonymous namespace
 
 WebMediaPlayerMS::WebMediaPlayerMS(
@@ skipping 240 matching lines @@
 
 void WebMediaPlayerMS::paint(blink::WebCanvas* canvas,
                              const blink::WebRect& rect,
                              unsigned char alpha,
                              SkXfermode::Mode mode) {
   DVLOG(3) << "WebMediaPlayerMS::paint";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   media::Context3D context_3d;
   if (current_frame_.get() &&
-      current_frame_->format() == media::VideoFrame::NATIVE_TEXTURE) {
+      current_frame_->storage_type() == media::VideoFrame::STORAGE_TEXTURE) {
     cc::ContextProvider* provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     // GPU Process crashed.
     if (!provider)
       return;
     context_3d = media::Context3D(provider->ContextGL(), provider->GrContext());
     DCHECK(context_3d.gl);
   }
   gfx::RectF dest_rect(rect.x, rect.y, rect.width, rect.height);
   video_renderer_.Paint(current_frame_, canvas, dest_rect, alpha, mode,
@@ skipping 67 matching lines @@
   TRACE_EVENT0("media", "WebMediaPlayerMS:copyVideoTextureToPlatformTexture");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_refptr<media::VideoFrame> video_frame;
   {
     base::AutoLock auto_lock(current_frame_lock_);
     video_frame = current_frame_;
   }
 
   if (!video_frame.get() ||
-      video_frame->format() != media::VideoFrame::NATIVE_TEXTURE) {
+      video_frame->storage_type() != media::VideoFrame::STORAGE_TEXTURE) {
     return false;
   }
 
   // TODO(dshwang): need more elegant way to convert WebGraphicsContext3D to
   // GLES2Interface.
   gpu::gles2::GLES2Interface* gl =
       static_cast<gpu_blink::WebGraphicsContext3DImpl*>(web_graphics_context)
           ->GetGLInterface();
   media::SkCanvasVideoRenderer::CopyVideoFrameTextureToGLTexture(
       gl, video_frame.get(), texture, internal_format, type, premultiply_alpha,
@@ skipping 114 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 blink::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace content