Merge 121076 - [chromium] LayerRendererChromium is not getting visibility messages in single thread…

Source/WebCore/platform/graphics/chromium/cc/CCVideoLayerImpl.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  */
 
 #include "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "cc/CCVideoLayerImpl.h"
 
 #include "Extensions3DChromium.h"
 #include "GraphicsContext3D.h"
-#include "LayerRendererChromium.h"
+#include "LayerRendererChromium.h" // For GLC macro
 #include "LayerTextureSubImage.h"
 #include "NotImplemented.h"
 #include "ProgramBinding.h"
 #include "TextureManager.h" // For TextureAllocator
 #include "cc/CCLayerTreeHostImpl.h"
 #include "cc/CCProxy.h"
 #include "cc/CCQuadCuller.h"
 #include "cc/CCStreamVideoDrawQuad.h"
 #include "cc/CCTextureDrawQuad.h"
 #include "cc/CCYUVVideoDrawQuad.h"
@@ skipping 23 matching lines @@
 }
 
 CCVideoLayerImpl::~CCVideoLayerImpl()
 {
     // See comment in constructor for why this doesn't need a lock.
     ASSERT(CCProxy::isMainThreadBlocked());
     if (m_provider) {
         m_provider->setVideoFrameProviderClient(0);
         m_provider = 0;
     }
-    freePlaneData(layerTreeHostImpl()->layerRenderer());
+    freePlaneData(layerTreeHostImpl()->context());
 
 #if !ASSERT_DISABLED
     for (unsigned i = 0; i < WebKit::WebVideoFrame::maxPlanes; ++i)
         ASSERT(!m_framePlanes[i].textureId);
 #endif
 }
 
 void CCVideoLayerImpl::stopUsingProvider()
 {
     // Block the provider from shutting down until this client is done
@@ skipping 29 matching lines @@
     // Explicitly lock and unlock the provider mutex so it can be held from
     // willDraw to didDraw. Since the compositor thread is in the middle of
     // drawing, the layer will not be destroyed before didDraw is called.
     // Therefore, the only thing that will prevent this lock from being released
     // is the GPU process locking it. As the GPU process can't cause the
     // destruction of the provider (calling stopUsingProvider), holding this
     // lock should not cause a deadlock.
     m_providerMutex.lock();
 
     willDrawInternal(layerRenderer, context);
-    freeUnusedPlaneData(layerRenderer);
+    freeUnusedPlaneData(context);
 
     if (!m_frame)
         m_providerMutex.unlock();
 }
 
 void CCVideoLayerImpl::willDrawInternal(CCRenderer* layerRenderer, CCGraphicsContext* context)
 {
     ASSERT(CCProxy::isImplThread());
 
     if (!m_provider) {
@@ skipping 13 matching lines @@
         m_frame = 0;
         return;
     }
 
     if (m_frame->planes() > WebKit::WebVideoFrame::maxPlanes) {
         m_provider->putCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
 
-    if (!allocatePlaneData(layerRenderer)) {
+    if (!allocatePlaneData(layerRenderer, context)) {
         m_provider->putCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
 
     if (!copyPlaneData(layerRenderer, context)) {
         m_provider->putCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
@@ skipping 102 matching lines @@
     // width of the Y texture by 2 for proper alignment. This must happen
     // always, even if Y's texture does not have padding bytes.
     if (plane == WebKit::WebVideoFrame::yPlane && frame.format() == WebKit::WebVideoFrame::FormatYV12) {
         if (hasPaddingBytes(frame, WebKit::WebVideoFrame::uPlane))
             visibleWidth = originalWidth - 2;
     }
 
     return IntSize(visibleWidth, visibleHeight);
 }
 
-bool CCVideoLayerImpl::FramePlane::allocateData(CCRenderer* layerRenderer)
+bool CCVideoLayerImpl::FramePlane::allocateData(CCGraphicsContext* context)
 {
     if (textureId)
         return true;
 
-    textureId = layerRenderer->contentsTextureAllocator()->createTexture(size, format);
+    GraphicsContext3D* context3D = context->context3D();
+    if (!context3D)
+        return false;
+
+    GLC(context3D, textureId = context3D->createTexture());
+    GLC(context3D, context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
+    // Do basic linear filtering on resize.
+    GLC(context3D, context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR));
+    GLC(context3D, context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
+    // NPOT textures in GL ES only work when the wrap mode is set to GraphicsContext3D::CLAMP_TO_EDGE.
+    GLC(context3D, context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE));
+    GLC(context3D, context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
+
+    GLC(context3D, context3D->texImage2DResourceSafe(GraphicsContext3D::TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GraphicsContext3D::UNSIGNED_BYTE));
+
     return textureId;
 }
 
-void CCVideoLayerImpl::FramePlane::freeData(CCRenderer* layerRenderer)
+void CCVideoLayerImpl::FramePlane::freeData(CCGraphicsContext* context)
 {
     if (!textureId)
         return;
 
-    layerRenderer->contentsTextureAllocator()->deleteTexture(textureId, size, format);
+    GraphicsContext3D* context3D = context->context3D();
+    if (!context3D)
+        return;
+
+    GLC(context3D, context3D->deleteTexture(textureId));
     textureId = 0;
 }
 
-bool CCVideoLayerImpl::allocatePlaneData(CCRenderer* layerRenderer)
+bool CCVideoLayerImpl::allocatePlaneData(CCRenderer* layerRenderer, CCGraphicsContext* context)
 {
     int maxTextureSize = layerRenderer->capabilities().maxTextureSize;
     for (unsigned planeIndex = 0; planeIndex < m_frame->planes(); ++planeIndex) {
         CCVideoLayerImpl::FramePlane& plane = m_framePlanes[planeIndex];
 
         IntSize requiredTextureSize(m_frame->stride(planeIndex), videoFrameDimension(m_frame->height(), planeIndex, m_frame->format()));
         // FIXME: Remove the test against maxTextureSize when tiled layers are implemented.
         if (requiredTextureSize.isZero() || requiredTextureSize.width() > maxTextureSize || requiredTextureSize.height() > maxTextureSize)
             return false;
 
         if (plane.size != requiredTextureSize || plane.format != m_format) {
-            plane.freeData(layerRenderer);
+            plane.freeData(context);
             plane.size = requiredTextureSize;
             plane.format = m_format;
         }
 
         if (!plane.textureId) {
-            if (!plane.allocateData(layerRenderer))
+            if (!plane.allocateData(context))
                 return false;
             plane.visibleSize = computeVisibleSize(*m_frame, planeIndex);
         }
     }
     return true;
 }
 
 bool CCVideoLayerImpl::copyPlaneData(CCRenderer* layerRenderer, CCGraphicsContext* context)
 {
     size_t softwarePlaneCount = m_frame->planes();
@@ skipping 12 matching lines @@
         const uint8_t* softwarePlanePixels = static_cast<const uint8_t*>(m_frame->data(softwarePlaneIndex));
         IntRect planeRect(IntPoint(), plane.size);
 
         context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, plane.textureId);
         uploader.setSubImageSize(plane.size);
         uploader.upload(softwarePlanePixels, planeRect, planeRect, planeRect, plane.format, context);
     }
     return true;
 }
 
-void CCVideoLayerImpl::freePlaneData(CCRenderer* layerRenderer)
+void CCVideoLayerImpl::freePlaneData(CCGraphicsContext* context)
 {
     for (unsigned i = 0; i < WebKit::WebVideoFrame::maxPlanes; ++i)
-        m_framePlanes[i].freeData(layerRenderer);
+        m_framePlanes[i].freeData(context);
 }
 
-void CCVideoLayerImpl::freeUnusedPlaneData(CCRenderer* layerRenderer)
+void CCVideoLayerImpl::freeUnusedPlaneData(CCGraphicsContext* context)
 {
     unsigned firstUnusedPlane = m_frame ? m_frame->planes() : 0;
     for (unsigned i = firstUnusedPlane; i < WebKit::WebVideoFrame::maxPlanes; ++i)
-        m_framePlanes[i].freeData(layerRenderer);
+        m_framePlanes[i].freeData(context);
 }
 
 void CCVideoLayerImpl::didReceiveFrame()
 {
     setNeedsRedraw();
 }
 
 void CCVideoLayerImpl::didUpdateMatrix(const float matrix[16])
 {
     m_streamTextureMatrix = WebKit::WebTransformationMatrix(
         matrix[0], matrix[1], matrix[2], matrix[3],
         matrix[4], matrix[5], matrix[6], matrix[7],
         matrix[8], matrix[9], matrix[10], matrix[11],
         matrix[12], matrix[13], matrix[14], matrix[15]);
     setNeedsRedraw();
 }
 
 void CCVideoLayerImpl::didLoseContext()
 {
-    freePlaneData(layerTreeHostImpl()->layerRenderer());
+    freePlaneData(layerTreeHostImpl()->context());
 }
 
 void CCVideoLayerImpl::setNeedsRedraw()
 {
     layerTreeHostImpl()->setNeedsRedraw();
 }
 
 void CCVideoLayerImpl::dumpLayerProperties(TextStream& ts, int indent) const
 {
     writeIndent(ts, indent);
     ts << "video layer\n";
     CCLayerImpl::dumpLayerProperties(ts, indent);
 }
 
 }
 
 #endif // USE(ACCELERATED_COMPOSITING)