Fixing issues needed to get Ganesh working with SurfaceTextures.

bug: 5013645
Change-Id: I255a19c68d8a98231b1500d93d21649d15d70820

7 files changed, 74 insertions, 11 deletions

diff --git a/Source/WebCore/platform/graphics/android/BaseRenderer.cpp b/Source/WebCore/platform/graphics/android/BaseRenderer.cpp
index d73c30f..68af1d6 100644
--- a/Source/WebCore/platform/graphics/android/BaseRenderer.cpp
+++ b/Source/WebCore/platform/graphics/android/BaseRenderer.cpp
@@ -120,6 +120,11 @@ int BaseRenderer::renderTiledContent(const TileRenderInfo& renderInfo)
     SkCanvas canvas;
     setupCanvas(renderInfo, &canvas);
 
+    if (!canvas.getDevice()) {
+        XLOG("Error: No Device");
+        return 0;
+    }
+
     if (visualIndicator)
         canvas.save();
 
diff --git a/Source/WebCore/platform/graphics/android/BaseTile.cpp b/Source/WebCore/platform/graphics/android/BaseTile.cpp
index 60c1ebb..cf769ae 100644
--- a/Source/WebCore/platform/graphics/android/BaseTile.cpp
+++ b/Source/WebCore/platform/graphics/android/BaseTile.cpp
@@ -73,7 +73,6 @@ BaseTile::BaseTile(bool isLayerTile)
     ClassTracker::instance()->increment("BaseTile");
 #endif
     m_currentDirtyAreaIndex = 0;
-    m_renderer = new RasterRenderer();
 
     // For EglImage Mode, the internal buffer should be 2.
     // And for Async Surface Texture mode, this is 3.
diff --git a/Source/WebCore/platform/graphics/android/DoubleBufferedTexture.cpp b/Source/WebCore/platform/graphics/android/DoubleBufferedTexture.cpp
index 569f987..4c5af9e 100644
--- a/Source/WebCore/platform/graphics/android/DoubleBufferedTexture.cpp
+++ b/Source/WebCore/platform/graphics/android/DoubleBufferedTexture.cpp
@@ -82,6 +82,8 @@ SharedTexture* DoubleBufferedTexture::getReadableTexture()
 
 EGLContext DoubleBufferedTexture::producerAcquireContext()
 {
+    if (m_sharedTextureMode == SurfaceTextureMode)
+        return EGL_NO_CONTEXT;
 
     if (m_pContext != EGL_NO_CONTEXT) {
         LOGV("AquireContext has previously generated a context.\n");
diff --git a/Source/WebCore/platform/graphics/android/GaneshContext.cpp b/Source/WebCore/platform/graphics/android/GaneshContext.cpp
index 6118aef..03e6eb7 100644
--- a/Source/WebCore/platform/graphics/android/GaneshContext.cpp
+++ b/Source/WebCore/platform/graphics/android/GaneshContext.cpp
@@ -85,14 +85,25 @@ void GaneshContext::flush()
 
 SkDevice* GaneshContext::getDeviceForBaseTile(const TileRenderInfo& renderInfo)
 {
+    // Ganesh should be the only code in the rendering thread that is using GL
+    // and setting the EGLContext.  If this is not the case then we need to
+    // reset the Ganesh context to prevent rendering issues.
+    bool contextNeedsReset = false;
+    if (eglGetCurrentContext() != m_surfaceContext) {
+        XLOG("Warning: EGLContext has Changed! %p, %p", m_surfaceContext,
+                                                        eglGetCurrentContext());
+        contextNeedsReset = true;
+    }
+
     SkDevice* device = 0;
     if (renderInfo.textureInfo->getSharedTextureMode() == SurfaceTextureMode)
         device = getDeviceForBaseTileSurface(renderInfo);
     else if (renderInfo.textureInfo->getSharedTextureMode() == EglImageMode)
         device = getDeviceForBaseTileFBO(renderInfo);
 
-    // TODO only need to reset if others are sharing our context
-    if (device)
+    // We must reset the Ganesh context only after we are sure we have
+    // re-established our EGLContext as the current context.
+    if (device && contextNeedsReset)
         getGrContext()->resetContext();
 
     return device;
@@ -100,11 +111,22 @@ SkDevice* GaneshContext::getDeviceForBaseTile(const TileRenderInfo& renderInfo)
 
 SkDevice* GaneshContext::getDeviceForBaseTileSurface(const TileRenderInfo& renderInfo)
 {
-    EGLDisplay display = eglGetCurrentDisplay();
-    GLUtils::checkEglError("eglGetCurrentDisplay");
+    EGLDisplay display;
 
     if (!m_surfaceContext) {
 
+        if(eglGetCurrentContext() != EGL_NO_CONTEXT) {
+            XLOG("ERROR: should not have a context yet");
+        }
+
+        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+        GLUtils::checkEglError("eglGetDisplay");
+
+        EGLint majorVersion;
+        EGLint minorVersion;
+        EGLBoolean returnValue = eglInitialize(display, &majorVersion, &minorVersion);
+        GLUtils::checkEglError("eglInitialize", returnValue);
+
         EGLint numConfigs;
         static const EGLint configAttribs[] = {
             EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
@@ -126,26 +148,32 @@ SkDevice* GaneshContext::getDeviceForBaseTileSurface(const TileRenderInfo& rende
 
         m_surfaceContext = eglCreateContext(display, m_surfaceConfig, NULL, contextAttribs);
         GLUtils::checkEglError("eglCreateContext");
+    } else {
+        display = eglGetCurrentDisplay();
+        GLUtils::checkEglError("eglGetCurrentDisplay");
     }
 
-    if (renderInfo.textureInfo->m_eglSurface == EGL_NO_SURFACE) {
+    TransferQueue* tileQueue = TilesManager::instance()->transferQueue();
+
+    if (tileQueue->m_eglSurface == EGL_NO_SURFACE) {
 
         const float tileWidth = renderInfo.tileSize.width();
         const float tileHeight = renderInfo.tileSize.height();
-        ANativeWindow* anw = renderInfo.textureInfo->m_ANW.get();
+
+        ANativeWindow* anw = tileQueue->m_ANW.get();
 
         int result = ANativeWindow_setBuffersGeometry(anw, (int)tileWidth,
                 (int)tileHeight, WINDOW_FORMAT_RGBA_8888);
 
         renderInfo.textureInfo->m_width = tileWidth;
         renderInfo.textureInfo->m_height = tileHeight;
-        renderInfo.textureInfo->m_eglSurface = eglCreateWindowSurface(display, m_surfaceConfig, anw, NULL);
+        tileQueue->m_eglSurface = eglCreateWindowSurface(display, m_surfaceConfig, anw, NULL);
 
         GLUtils::checkEglError("eglCreateWindowSurface");
         XLOG("eglCreateWindowSurface");
     }
 
-    EGLBoolean returnValue = eglMakeCurrent(display, renderInfo.textureInfo->m_eglSurface, renderInfo.textureInfo->m_eglSurface, m_surfaceContext);
+    EGLBoolean returnValue = eglMakeCurrent(display, tileQueue->m_eglSurface, tileQueue->m_eglSurface, m_surfaceContext);
     GLUtils::checkEglError("eglMakeCurrent", returnValue);
     XLOG("eglMakeCurrent");
 
diff --git a/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp b/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp
index 8f4d0b3..9268ac0 100644
--- a/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp
+++ b/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp
@@ -84,6 +84,21 @@ void GaneshRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* can
 
     GaneshContext* ganesh = GaneshContext::instance();
 
+#if !DEPRECATED_SURFACE_TEXTURE_MODE
+    if (renderInfo.textureInfo->getSharedTextureMode() == SurfaceTextureMode) {
+        TransferQueue* tileQueue = TilesManager::instance()->transferQueue();
+
+        tileQueue->lockQueue();
+
+        bool ready = tileQueue->readyForUpdate();
+        if (!ready) {
+            XLOG("!ready");
+            tileQueue->unlockQueue();
+            return;
+        }
+    }
+#endif
+
     SkDevice* device = NULL;
     if (renderInfo.tileSize.width() == TilesManager::tileWidth()
             && renderInfo.tileSize.height() == TilesManager::tileHeight()) {
@@ -102,6 +117,7 @@ void GaneshRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* can
 
     // set the GPU device to the canvas
     canvas->setDevice(device);
+    canvas->setDeviceFactory(device->getDeviceFactory());
 
     // invert canvas contents
     if (renderInfo.textureInfo->getSharedTextureMode() == EglImageMode) {
@@ -134,7 +150,12 @@ void GaneshRenderer::renderingComplete(const TileRenderInfo& renderInfo, SkCanva
     // In SurfaceTextureMode we must call swapBuffers to unlock and post the
     // tile's ANativeWindow (i.e. SurfaceTexture) buffer
     if (renderInfo.textureInfo->getSharedTextureMode() == SurfaceTextureMode) {
-        eglSwapBuffers(eglGetCurrentDisplay(), renderInfo.textureInfo->m_eglSurface);
+#if !DEPRECATED_SURFACE_TEXTURE_MODE
+        TransferQueue* tileQueue = TilesManager::instance()->transferQueue();
+        eglSwapBuffers(eglGetCurrentDisplay(), tileQueue->m_eglSurface);
+        tileQueue->addItemInTransferQueue(&renderInfo);
+        tileQueue->unlockQueue();
+#endif
     }
 
     if (renderInfo.measurePerf)
diff --git a/Source/WebCore/platform/graphics/android/TransferQueue.cpp b/Source/WebCore/platform/graphics/android/TransferQueue.cpp
index a4fd594..1a377f2 100644
--- a/Source/WebCore/platform/graphics/android/TransferQueue.cpp
+++ b/Source/WebCore/platform/graphics/android/TransferQueue.cpp
@@ -53,7 +53,8 @@
 namespace WebCore {
 
 TransferQueue::TransferQueue()
-    : m_transferQueueIndex(0)
+    : m_eglSurface(EGL_NO_SURFACE)
+    , m_transferQueueIndex(0)
     , m_fboID(0)
     , m_sharedSurfaceTextureId(0)
     , m_hasGLContext(true)
diff --git a/Source/WebCore/platform/graphics/android/TransferQueue.h b/Source/WebCore/platform/graphics/android/TransferQueue.h
index 550623e..291215c 100644
--- a/Source/WebCore/platform/graphics/android/TransferQueue.h
+++ b/Source/WebCore/platform/graphics/android/TransferQueue.h
@@ -63,12 +63,19 @@ public:
     bool readyForUpdate();
 
     void interruptTransferQueue(bool);
+
+    void lockQueue() { m_transferQueueItemLocks.lock(); }
+    void unlockQueue() { m_transferQueueItemLocks.unlock(); }
+
     // This queue can be accessed from UI and TexGen thread, therefore, we need
     // a lock to protect its access
     TileTransferData* m_transferQueue;
 
     sp<ANativeWindow> m_ANW;
 
+    // EGL wrapper around m_ANW for use by the GaneshRenderer
+    EGLSurface m_eglSurface;
+
 private:
     bool getHasGLContext();
     void setHasGLContext(bool hasContext);