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"
@@ skipping 22 matching lines @@
 #include <public/Platform.h>
 #include <public/WebCString.h>
 #include <public/WebCanvas.h>
 #include <public/WebCompositorSupport.h>
 #include <public/WebMimeRegistry.h>
 #include <public/WebRect.h>
 #include <public/WebSize.h>
 #include <public/WebString.h>
 #include <public/WebURL.h>
 
+#if defined(OS_ANDROID)
+#include "GrContext.h"
+#include "GrTexture.h"
+#include "GrTypes.h"
+#include "SkCanvas.h"
+#include "SkGrPixelRef.h"
+#endif
+
 #if USE(ACCELERATED_COMPOSITING)
 #include "RenderLayerCompositor.h"
 #endif
 
 #include <wtf/Assertions.h>
 #include <wtf/text/CString.h>
 
 using namespace WebCore;
 
 namespace WebKit {
@@ skipping 559 matching lines @@
     paintCurrentFrameInContext(context, rect);
 }
 
 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();
+
+        // On Android, video frame is emitted as GL_TEXTURE_EXTERNAL_OES texture. We use a different path to
+        // paint the video frame into the context.
+#if defined(OS_ANDROID)
+        RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
+        paintOnAndroid(context, context3D.get(), rect, platformContext->getNormalizedAlpha());
+#else
         WebCanvas* canvas = platformContext->canvas();
         m_webMediaPlayer->paint(canvas, rect, platformContext->getNormalizedAlpha());
+#endif
     }
 }
 
 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;
@@ skipping 125 matching lines @@
     case WebMimeRegistry::IsNotSupported:
         return MediaPlayer::IsNotSupported;
     case WebMimeRegistry::IsSupported:
         return MediaPlayer::IsSupported;
     case WebMimeRegistry::MayBeSupported:
         return MediaPlayer::MayBeSupported;
     }
     return MediaPlayer::IsNotSupported;
 }
 
+#if defined(OS_ANDROID)
+void WebMediaPlayerClientImpl::paintOnAndroid(WebCore::GraphicsContext* context, WebCore::GraphicsContext3D* context3D, const IntRect& rect, uint8_t alpha)
+{
+    if (!context || !context3D || !m_webMediaPlayer || context->paintingDisabled())
+        return;
+
+    Extensions3D* extensions = context3D->getExtensions();
+    if (!extensions || !extensions->supports("GL_CHROMIUM_copy_texture") || !extensions->supports("GL_CHROMIUM_flipy")
+        || !context3D->makeContextCurrent())
+        return;
+
+    // Copy video texture into a RGBA texture based bitmap first as video texture on Android is GL_TEXTURE_EXTERNAL_OES
+    // which is not supported by Skia yet. The bitmap's size needs to be the same as the video.
+    int videoWidth = naturalSize().width();
+    int videoHeight = naturalSize().height();
+
+    // Check if we could reuse existing texture based bitmap.
+    // Otherwise, release existing texture based bitmap and allocate a new one based on video size.
+    if (videoWidth != m_bitmap.width() || videoHeight != m_bitmap.height() || !m_texture.get()) {
+        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;
+        m_texture.reset(ct->createUncachedTexture(desc, NULL, 0));
+        if (!m_texture.get())
+            return;
+        m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, videoWidth, videoHeight);
+        m_bitmap.setPixelRef(new SkGrPixelRef(m_texture))->unref();
+    }
+
+    // Copy video texture to bitmap texture.
+    WebGraphicsContext3D* webGraphicsContext3D = GraphicsContext3DPrivate::extractWebGraphicsContext3D(context3D);
+    PlatformGraphicsContext* platformContext = context->platformContext();
+    WebCanvas* canvas = platformContext->canvas();
+    unsigned int textureId = static_cast<unsigned int>(m_texture->getTextureHandle());
+    if (!m_webMediaPlayer->copyVideoTextureToPlatformTexture(webGraphicsContext3D, textureId, 0, GraphicsContext3D::RGBA, true, false)) { return; }
+
+    // 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.
+    SkRect dest;
+    dest.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
+    SkPaint paint;
+    paint.setAlpha(alpha);
+    canvas->drawBitmapRect(m_bitmap, NULL, dest, &paint);
+}
+#endif
+
 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)