Enable video painting on Canvas for Chrome on Android.

Source/WebKit/chromium/src/WebMediaPlayerClientImpl.cpp

 // Copyright (c) 2009 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 "config.h"
 #include "WebMediaPlayerClientImpl.h"
 
 #if ENABLE(VIDEO)
 
 #include "AudioBus.h"
 #include "AudioSourceProvider.h"
 #include "AudioSourceProviderClient.h"
 #include "Frame.h"
 #include "GraphicsContext.h"
 #include "GraphicsContext3DPrivate.h"
 #include "GraphicsLayerChromium.h"
+#include "GrContext.h"
+#include "GrTexture.h"
+#include "GrTypes.h"
 #include "HTMLMediaElement.h"
 #include "IntSize.h"
 #include "KURL.h"
 #include "MediaPlayer.h"
 #include "NotImplemented.h"
 #include "PlatformContextSkia.h"
 #include "RenderView.h"
+#include "SkRefCnt.h"
+#include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkGrPixelRef.h"
 #include "TimeRanges.h"
 #include "WebAudioSourceProvider.h"
 #include "WebDocument.h"
 #include "WebFrameClient.h"
 #include "WebFrameImpl.h"
 #include "WebHelperPluginImpl.h"
 #include "WebMediaPlayer.h"
 #include "WebMediaSourceImpl.h"
 #include "WebViewImpl.h"
 #include <public/Platform.h>
@@ skipping 583 matching lines @@
     // Normally GraphicsContext operations do nothing when painting is disabled.
     // Since we're accessing platformContext() directly we have to manually
     // check.
     if (m_webMediaPlayer && !context->paintingDisabled()) {
         PlatformGraphicsContext* platformContext = context->platformContext();
         WebCanvas* canvas = platformContext->canvas();
         m_webMediaPlayer->paint(canvas, rect, platformContext->getNormalizedAlpha());
     }
 }
 
+bool WebMediaPlayerClientImpl::copyVideoTextureToCanvas(WebCore::GraphicsContext* context, WebCore::GraphicsContext3D* context3D)

[qinmin, 2013/04/05 17:30:28]

why this function takes a GraphicsContext param instead of taking canvas while
the name of the function is xxxxToCanvas?

+{
+    if (!context || !context3D || !m_webMediaPlayer || context->paintingDisabled())
+        return false;
+
+    Extensions3D* extensions = context3D->getExtensions();
+    if (!extensions || !extensions->supports("GL_CHROMIUM_copy_texture") || !extensions->supports("GL_CHROMIUM_flipy")
+        || !context3D->makeContextCurrent())
+        return false;
+
+    WebGraphicsContext3D* webGraphicsContext3D = GraphicsContext3DPrivate::extractWebGraphicsContext3D(context3D);
+    PlatformGraphicsContext* platformContext = context->platformContext();
+    WebCanvas* canvas = platformContext->canvas();
+
+    // Create a temporary RGBA texture based SkBitmap where the video will be copied into.
+    // The bitmap's size is the same as the video.
+    unsigned int videoWidth = naturalSize().width(), videoHeight = naturalSize().height();

[qinmin, 2013/04/05 17:30:28]

split it into multiple lines.

+    GrTextureDesc desc;
+    desc.fConfig = kSkia8888_GrPixelConfig;
+    desc.fWidth = videoWidth;
+    desc.fHeight = videoHeight;
+    desc.fOrigin = kTopLeft_GrSurfaceOrigin;
+    desc.fFlags = (kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit);
+    GrContext* ct = context3D->grContext();
+    if (!ct)
+        return false;
+    SkAutoTUnref<GrTexture> texture(ct->createUncachedTexture(desc, NULL, 0));

[Ken Russell (switch to Gerrit), 2013/04/05 22:40:38]

If this is the code structure you want, then shouldn't there be an attempt to
re-use these textures from frame to frame? Otherwise allocation and deallocation
will happen every time which will be inefficient.

+    if (!texture.get())
+        return false;
+    unsigned int textureId = static_cast<unsigned int>(texture->getTextureHandle());
+
+    // Copy video texture to bitmap texture.
+    if (!m_webMediaPlayer->copyVideoTextureToPlatformTexture(webGraphicsContext3D, textureId, 0, GraphicsContext3D::RGBA, true, false)) {

[qinmin, 2013/04/05 17:30:28]

no { for if statement with only 1 lines

+        return false;
+    }
+
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kARGB_8888_Config, videoWidth, videoHeight);
+    bitmap.setPixelRef(new SkGrPixelRef(texture))->unref();
+
+    // Draw the texture based bitmap onto the Canvas. If the canvas is hardware based, this will do a GPU-GPU texture copy. If the canvas is software based,

[scherkus (not reviewing), 2013/04/05 20:47:09]

do we have GPU-based canvas implementations yet?

[hkuang, 2013/04/09 17:46:10]

The SkCanvas will be software based when the size is smaller than a threshold as
using software get better performance than using opengGL. When above that size
threshold, the Canvas will be hardware based. Details are in the code
HTMLCanvasElement::createImageBuffer()

+    // the texture based bitmap will be readbacked to system memory then draw onto the canvas.
+    canvas->drawBitmap(bitmap, 0, 0);

[Ken Russell (switch to Gerrit), 2013/04/05 22:40:38]

This can't be correct. The destRect argument from
HTMLVideoElement::paintCurrentFrameInContext is being discarded at this point.

+    return true;
+}
+
 bool WebMediaPlayerClientImpl::copyVideoTextureToPlatformTexture(WebCore::GraphicsContext3D* context, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY)
 {
     if (!context || !m_webMediaPlayer)
         return false;
     Extensions3D* extensions = context->getExtensions();
     if (!extensions || !extensions->supports("GL_CHROMIUM_copy_texture") || !extensions->supports("GL_CHROMIUM_flipy") || !context->makeContextCurrent())
         return false;
     WebGraphicsContext3D* webGraphicsContext3D = GraphicsContext3DPrivate::extractWebGraphicsContext3D(context);
     return m_webMediaPlayer->copyVideoTextureToPlatformTexture(webGraphicsContext3D, texture, level, internalFormat, premultiplyAlpha, flipY);
 }
@@ skipping 192 matching lines @@
 {
     if (m_client)
         m_client->setFormat(numberOfChannels, sampleRate);
 }
 
 #endif
 
 } // namespace WebKit
 
 #endif  // ENABLE(VIDEO)