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 579 matching lines @@
 }
 
 void WebMediaPlayerClientImpl::paintCurrentFrameInContext(GraphicsContext* context, const IntRect& rect)
 {
     // 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();
+
+        // Go through the fast path trying to do a GPU-GPU texture copy without readback to system memory if possible.
+        // Otherwise, it will fallback to the normal SW path.
+        RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
+        if (context3D && paintVideoTextureInContext(context, context3D.get()))

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

This is still wrong as it's discarding the incoming destination rectangle.

+            return;
+
+        // Normal pure SW path
         m_webMediaPlayer->paint(canvas, rect, platformContext->getNormalizedAlpha());
     }
 }
 
 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())
@@ skipping 126 matching lines @@
     case WebMimeRegistry::IsNotSupported:
         return MediaPlayer::IsNotSupported;
     case WebMimeRegistry::IsSupported:
         return MediaPlayer::IsSupported;
     case WebMimeRegistry::MayBeSupported:
         return MediaPlayer::MayBeSupported;
     }
     return MediaPlayer::IsNotSupported;
 }
 
+bool WebMediaPlayerClientImpl::paintVideoTextureInContext(WebCore::GraphicsContext* context, WebCore::GraphicsContext3D* context3D)

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

Either this needs to be made to work correctly on all platforms (it definitely
won't; see above) or it should be #ifdef'd so that on !OS_ANDROID it immediately
returns false.

+{
+    if (!context || !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();
+    unsigned int videoHeight = naturalSize().height();
+    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));
+    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)) { 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,
+    // the texture based bitmap will be readbacked to system memory then draw onto the canvas.
+    canvas->drawBitmap(bitmap, 0, 0);
+    return true;
+}
+
 void WebMediaPlayerClientImpl::startDelayedLoad()
 {
     ASSERT(m_delayingLoad);
     ASSERT(!m_webMediaPlayer);
 
     m_delayingLoad = false;
 
     loadInternal();
 }
 
@@ skipping 50 matching lines @@
 {
     if (m_client)
         m_client->setFormat(numberOfChannels, sampleRate);
 }
 
 #endif
 
 } // namespace WebKit
 
 #endif  // ENABLE(VIDEO)