diff options
Diffstat (limited to 'Source/WebCore')
18 files changed, 346 insertions, 100 deletions
diff --git a/Source/WebCore/platform/graphics/android/BaseLayerAndroid.cpp b/Source/WebCore/platform/graphics/android/BaseLayerAndroid.cpp index a09eb35..014fa40 100644 --- a/Source/WebCore/platform/graphics/android/BaseLayerAndroid.cpp +++ b/Source/WebCore/platform/graphics/android/BaseLayerAndroid.cpp @@ -112,7 +112,8 @@ void BaseLayerAndroid::drawCanvas(SkCanvas* canvas) } #if USE(ACCELERATED_COMPOSITING) -bool BaseLayerAndroid::drawBasePictureInGL(SkRect& viewport, float scale, double currentTime) +bool BaseLayerAndroid::drawBasePictureInGL(SkRect& viewport, float scale, + double currentTime, bool* pagesSwapped) { if (!m_glWebViewState) return false; @@ -249,6 +250,8 @@ bool BaseLayerAndroid::drawBasePictureInGL(SkRect& viewport, float scale, double m_glWebViewState->setCurrentScale(scale); m_glWebViewState->swapPages(); m_glWebViewState->unlockBaseLayerUpdate(); + if (pagesSwapped) + *pagesSwapped = true; } m_glWebViewState->paintExtras(); @@ -259,7 +262,8 @@ bool BaseLayerAndroid::drawBasePictureInGL(SkRect& viewport, float scale, double bool BaseLayerAndroid::drawGL(LayerAndroid* compositedRoot, IntRect& viewRect, SkRect& visibleRect, IntRect& webViewRect, int titleBarHeight, - IntRect& screenClip, float scale, SkColor color) + IntRect& screenClip, float scale, + bool* pagesSwapped, SkColor color) { bool needsRedraw = false; #if USE(ACCELERATED_COMPOSITING) @@ -299,7 +303,8 @@ bool BaseLayerAndroid::drawGL(LayerAndroid* compositedRoot, shader->resetBlending(); double currentTime = WTF::currentTime(); - needsRedraw = drawBasePictureInGL(visibleRect, scale, currentTime); + needsRedraw = drawBasePictureInGL(visibleRect, scale, currentTime, + pagesSwapped); bool goingDown = m_previousVisible.fTop - visibleRect.fTop <= 0; bool goingLeft = m_previousVisible.fLeft - visibleRect.fLeft >= 0; m_glWebViewState->setDirection(goingDown, goingLeft); diff --git a/Source/WebCore/platform/graphics/android/BaseLayerAndroid.h b/Source/WebCore/platform/graphics/android/BaseLayerAndroid.h index 29ecf57..62aabb6 100644 --- a/Source/WebCore/platform/graphics/android/BaseLayerAndroid.h +++ b/Source/WebCore/platform/graphics/android/BaseLayerAndroid.h @@ -57,11 +57,12 @@ public: bool drawGL(LayerAndroid* compositedRoot, IntRect& rect, SkRect& viewport, IntRect& webViewRect, int titleBarHeight, IntRect& screenClip, - float scale, SkColor color = SK_ColorWHITE); + float scale, bool* pagesSwapped, SkColor color = SK_ColorWHITE); void swapExtra(BaseLayerAndroid* base) { m_extra.swap(base->m_extra); } private: #if USE(ACCELERATED_COMPOSITING) - bool drawBasePictureInGL(SkRect& viewport, float scale, double currentTime); + bool drawBasePictureInGL(SkRect& viewport, float scale, double currentTime, + bool* pagesSwapped); GLWebViewState* m_glWebViewState; android::Mutex m_drawLock; diff --git a/Source/WebCore/platform/graphics/android/BaseRenderer.cpp b/Source/WebCore/platform/graphics/android/BaseRenderer.cpp index 4fde188..ea6c8ec 100644 --- a/Source/WebCore/platform/graphics/android/BaseRenderer.cpp +++ b/Source/WebCore/platform/graphics/android/BaseRenderer.cpp @@ -29,7 +29,9 @@ #if USE(ACCELERATED_COMPOSITING) +#include "GaneshRenderer.h" #include "GLUtils.h" +#include "RasterRenderer.h" #include "SkBitmap.h" #include "SkBitmapRef.h" #include "SkCanvas.h" @@ -56,6 +58,26 @@ namespace WebCore { +BaseRenderer::RendererType BaseRenderer::g_currentType = BaseRenderer::Raster; + +BaseRenderer* BaseRenderer::createRenderer() +{ + if (g_currentType == Raster) + return new RasterRenderer(); + else if (g_currentType == Ganesh) + return new GaneshRenderer(); + return NULL; +} + +void BaseRenderer::swapRendererIfNeeded(BaseRenderer*& renderer) +{ + if (renderer->getType() == g_currentType) + return; + + delete renderer; + renderer = createRenderer(); +} + void BaseRenderer::drawTileInfo(SkCanvas* canvas, const TileRenderInfo& renderInfo, int pictureCount) { diff --git a/Source/WebCore/platform/graphics/android/BaseRenderer.h b/Source/WebCore/platform/graphics/android/BaseRenderer.h index 0ee9ebd..7780db1 100644 --- a/Source/WebCore/platform/graphics/android/BaseRenderer.h +++ b/Source/WebCore/platform/graphics/android/BaseRenderer.h @@ -80,6 +80,11 @@ public: RendererType getType() { return m_type; } + static BaseRenderer* createRenderer(); + static void swapRendererIfNeeded(BaseRenderer*& renderer); + static RendererType getCurrentRendererType() { return g_currentType; } + static void setCurrentRendererType(RendererType type) { g_currentType = type; } + protected: virtual void setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* canvas) = 0; @@ -96,6 +101,7 @@ protected: private: RendererType m_type; + static RendererType g_currentType; }; } // namespace WebCore diff --git a/Source/WebCore/platform/graphics/android/BaseTile.cpp b/Source/WebCore/platform/graphics/android/BaseTile.cpp index 4cbcf7c..6ab2cd2 100644 --- a/Source/WebCore/platform/graphics/android/BaseTile.cpp +++ b/Source/WebCore/platform/graphics/android/BaseTile.cpp @@ -86,6 +86,8 @@ BaseTile::BaseTile(bool isLayerTile) m_fullRepaint = new bool[m_maxBufferNumber]; for (int i = 0; i < m_maxBufferNumber; i++) m_fullRepaint[i] = true; + + m_renderer = BaseRenderer::createRenderer(); } BaseTile::~BaseTile() @@ -306,6 +308,9 @@ void BaseTile::paintBitmap() unsigned int pictureCount = 0; + // swap out the renderer if necessary + BaseRenderer::swapRendererIfNeeded(m_renderer); + // setup the common renderInfo fields; TileRenderInfo renderInfo; renderInfo.x = x; diff --git a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp index 2e379bc..07dda03 100644 --- a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp +++ b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp @@ -501,7 +501,8 @@ void GLWebViewState::resetLayersDirtyArea() bool GLWebViewState::drawGL(IntRect& rect, SkRect& viewport, IntRect* invalRect, IntRect& webViewRect, int titleBarHeight, - IntRect& clip, float scale, SkColor color) + IntRect& clip, float scale, bool* pagesSwapped, + SkColor color) { glFinish(); TilesManager::instance()->registerGLWebViewState(this); @@ -548,7 +549,8 @@ bool GLWebViewState::drawGL(IntRect& rect, SkRect& viewport, IntRect* invalRect, TilesManager::instance()->cleanupTilesTextures(); } - bool ret = baseLayer->drawGL(compositedRoot, rect, viewport, webViewRect, titleBarHeight, clip, scale, color); + bool ret = baseLayer->drawGL(compositedRoot, rect, viewport, webViewRect, + titleBarHeight, clip, scale, pagesSwapped, color); SkSafeRef(compositedRoot); SkSafeUnref(m_previouslyUsedRoot); m_previouslyUsedRoot = compositedRoot; diff --git a/Source/WebCore/platform/graphics/android/GLWebViewState.h b/Source/WebCore/platform/graphics/android/GLWebViewState.h index 6834974..4f8d4fe 100644 --- a/Source/WebCore/platform/graphics/android/GLWebViewState.h +++ b/Source/WebCore/platform/graphics/android/GLWebViewState.h @@ -220,7 +220,8 @@ public: bool drawGL(IntRect& rect, SkRect& viewport, IntRect* invalRect, IntRect& webViewRect, int titleBarHeight, - IntRect& clip, float scale, SkColor color = SK_ColorWHITE); + IntRect& clip, float scale, bool* pagesSwapped, + SkColor color = SK_ColorWHITE); void setBackgroundColor(SkColor color) { m_backgroundColor = color; } SkColor getBackgroundColor() { return m_backgroundColor; } diff --git a/Source/WebCore/platform/graphics/android/GaneshContext.cpp b/Source/WebCore/platform/graphics/android/GaneshContext.cpp index b316e5a..6118aef 100644 --- a/Source/WebCore/platform/graphics/android/GaneshContext.cpp +++ b/Source/WebCore/platform/graphics/android/GaneshContext.cpp @@ -28,6 +28,8 @@ #include "GaneshContext.h" #include "GLUtils.h" +#include "android/native_window.h" + #if USE(ACCELERATED_COMPOSITING) #ifdef DEBUG @@ -49,9 +51,12 @@ namespace WebCore { GaneshContext::GaneshContext() : m_grContext(0) - , m_baseTileDevice(0) - , m_baseTileFbo(0) + , m_baseTileDeviceFBO(0) + , m_baseTileFBO(0) , m_baseTileStencil(0) + , m_baseTileDeviceSurface(0) + , m_surfaceConfig(0) + , m_surfaceContext(EGL_NO_CONTEXT) { } @@ -72,10 +77,130 @@ GrContext* GaneshContext::getGrContext() return m_grContext; } -SkDevice* GaneshContext::getDeviceForBaseTile(GLuint textureId) +void GaneshContext::flush() +{ + if (m_grContext) + m_grContext->flush(); +} + +SkDevice* GaneshContext::getDeviceForBaseTile(const TileRenderInfo& renderInfo) +{ + 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) + getGrContext()->resetContext(); + + return device; +} + +SkDevice* GaneshContext::getDeviceForBaseTileSurface(const TileRenderInfo& renderInfo) +{ + EGLDisplay display = eglGetCurrentDisplay(); + GLUtils::checkEglError("eglGetCurrentDisplay"); + + if (!m_surfaceContext) { + + EGLint numConfigs; + static const EGLint configAttribs[] = { + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_RED_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, + EGL_ALPHA_SIZE, 8, + EGL_STENCIL_SIZE, 8, + EGL_NONE + }; + + eglChooseConfig(display, configAttribs, &m_surfaceConfig, 1, &numConfigs); + GLUtils::checkEglError("eglChooseConfig"); + + static const EGLint contextAttribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE + }; + + m_surfaceContext = eglCreateContext(display, m_surfaceConfig, NULL, contextAttribs); + GLUtils::checkEglError("eglCreateContext"); + } + + if (renderInfo.textureInfo->m_eglSurface == EGL_NO_SURFACE) { + + const float tileWidth = renderInfo.tileSize.width(); + const float tileHeight = renderInfo.tileSize.height(); + ANativeWindow* anw = renderInfo.textureInfo->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); + + GLUtils::checkEglError("eglCreateWindowSurface"); + XLOG("eglCreateWindowSurface"); + } + + EGLBoolean returnValue = eglMakeCurrent(display, renderInfo.textureInfo->m_eglSurface, renderInfo.textureInfo->m_eglSurface, m_surfaceContext); + GLUtils::checkEglError("eglMakeCurrent", returnValue); + XLOG("eglMakeCurrent"); + + if (!m_baseTileDeviceSurface) { + + GrPlatformSurfaceDesc surfaceDesc; + surfaceDesc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType; + surfaceDesc.fRenderTargetFlags = kNone_GrPlatformRenderTargetFlagBit; + surfaceDesc.fWidth = TilesManager::tileWidth(); + surfaceDesc.fHeight = TilesManager::tileHeight(); + surfaceDesc.fConfig = kRGBA_8888_GrPixelConfig; + surfaceDesc.fStencilBits = 8; + surfaceDesc.fPlatformRenderTarget = 0; + + GrContext* grContext = getGrContext(); + GrRenderTarget* renderTarget = (GrRenderTarget*) grContext->createPlatformSurface(surfaceDesc); + + SkBitmap bitmap; + bitmap.setConfig(SkBitmap::kARGB_8888_Config, + renderInfo.tileSize.width(), + renderInfo.tileSize.height()); + + m_baseTileDeviceSurface = new SkGpuDevice(grContext, bitmap, renderTarget); + renderTarget->unref(); + XLOG("generated device %p", m_baseTileDeviceSurface); + } + + GLUtils::checkGlError("getDeviceForBaseTile"); + return m_baseTileDeviceSurface; +} + +SkDevice* GaneshContext::getDeviceForBaseTileFBO(const TileRenderInfo& renderInfo) { - if (!m_baseTileFbo) { - glGenFramebuffers(1, &m_baseTileFbo); + const GLuint textureId = renderInfo.textureInfo->m_textureId; + const float tileWidth = renderInfo.tileSize.width(); + const float tileHeight = renderInfo.tileSize.height(); + + // bind to the current texture + glBindTexture(GL_TEXTURE_2D, textureId); + + // setup the texture if needed + if (renderInfo.textureInfo->m_width != tileWidth + || renderInfo.textureInfo->m_height != tileHeight) { + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tileWidth, tileHeight, + 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); + renderInfo.textureInfo->m_width = tileWidth; + renderInfo.textureInfo->m_height = tileHeight; + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + + if (!m_baseTileFBO) { + glGenFramebuffers(1, &m_baseTileFBO); XLOG("generated FBO"); } @@ -90,20 +215,21 @@ SkDevice* GaneshContext::getDeviceForBaseTile(GLuint textureId) XLOG("generated stencil"); } - glBindFramebuffer(GL_FRAMEBUFFER, m_baseTileFbo); + // bind the FBO and attach the texture and stencil + glBindFramebuffer(GL_FRAMEBUFFER, m_baseTileFBO); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_baseTileStencil); - if (!m_baseTileDevice) { + if (!m_baseTileDeviceFBO) { GrPlatformSurfaceDesc surfaceDesc; surfaceDesc.fSurfaceType = kRenderTarget_GrPlatformSurfaceType; surfaceDesc.fRenderTargetFlags = kNone_GrPlatformRenderTargetFlagBit; surfaceDesc.fWidth = TilesManager::tileWidth(); - surfaceDesc.fHeight = TilesManager::tileWidth(); + surfaceDesc.fHeight = TilesManager::tileHeight(); surfaceDesc.fConfig = kRGBA_8888_GrPixelConfig; surfaceDesc.fStencilBits = 8; - surfaceDesc.fPlatformRenderTarget = m_baseTileFbo; + surfaceDesc.fPlatformRenderTarget = m_baseTileFBO; GrContext* grContext = getGrContext(); GrRenderTarget* renderTarget = (GrRenderTarget*) grContext->createPlatformSurface(surfaceDesc); @@ -112,17 +238,16 @@ SkDevice* GaneshContext::getDeviceForBaseTile(GLuint textureId) bitmap.setConfig(SkBitmap::kARGB_8888_Config, TilesManager::tileWidth(), TilesManager::tileWidth()); - m_baseTileDevice = new SkGpuDevice(grContext, bitmap, renderTarget); + m_baseTileDeviceFBO = new SkGpuDevice(grContext, bitmap, renderTarget); renderTarget->unref(); - XLOG("generated device %p", m_baseTileDevice); + XLOG("generated device %p", m_baseTileDeviceFBO); } GLUtils::checkGlError("getDeviceForBaseTile"); - return m_baseTileDevice; + return m_baseTileDeviceFBO; } - } // namespace WebCore #endif // USE(ACCELERATED_COMPOSITING) diff --git a/Source/WebCore/platform/graphics/android/GaneshContext.h b/Source/WebCore/platform/graphics/android/GaneshContext.h index 9d90b96..12ea92d 100644 --- a/Source/WebCore/platform/graphics/android/GaneshContext.h +++ b/Source/WebCore/platform/graphics/android/GaneshContext.h @@ -28,6 +28,7 @@ #if USE(ACCELERATED_COMPOSITING) +#include "BaseRenderer.h" #include "GrContext.h" #include "SkGpuDevice.h" #include "TilesManager.h" @@ -38,19 +39,33 @@ class GaneshContext { public: static GaneshContext* instance(); - GrContext* getGrContext(); + SkDevice* getDeviceForBaseTile(const TileRenderInfo& renderInfo); - SkDevice* getDeviceForBaseTile(GLuint textureId); + void flush(); private: GaneshContext(); + GrContext* getGrContext(); + + // Creates a device for rendering into a SurfaceTexture via an EGLSurface + SkDevice* getDeviceForBaseTileSurface(const TileRenderInfo& renderInfo); + // Creates a device for rendering into a EGLImage via an FBO + SkDevice* getDeviceForBaseTileFBO(const TileRenderInfo& renderInfo); + GrContext* m_grContext; - SkGpuDevice* m_baseTileDevice; - GLuint m_baseTileFbo; + + // FBO specific variables + SkGpuDevice* m_baseTileDeviceFBO; + GLuint m_baseTileFBO; GLuint m_baseTileStencil; + // Surface specific variables + SkGpuDevice* m_baseTileDeviceSurface; + EGLConfig m_surfaceConfig; + EGLContext m_surfaceContext; + static GaneshContext* gInstance; }; diff --git a/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp b/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp index fcb0675..8f4d0b3 100644 --- a/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp +++ b/Source/WebCore/platform/graphics/android/GaneshRenderer.cpp @@ -34,12 +34,12 @@ #include "SkGpuDevice.h" #include "TilesManager.h" -#include <wtf/text/CString.h> #ifdef DEBUG #include <cutils/log.h> #include <wtf/CurrentTime.h> +#include <wtf/text/CString.h> #undef XLOG #define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "GaneshRenderer", __VA_ARGS__) @@ -63,7 +63,7 @@ static const String TAGS[] = { TAG_UPDATE_TEXTURE, }; -GaneshRenderer::GaneshRenderer() : BaseRenderer(BaseRenderer::Raster) +GaneshRenderer::GaneshRenderer() : BaseRenderer(BaseRenderer::Ganesh) { #ifdef DEBUG_COUNT ClassTracker::instance()->increment("GaneshRenderer"); @@ -82,37 +82,17 @@ void GaneshRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* can if (renderInfo.measurePerf) m_perfMon.start(TAG_CREATE_FBO); - const float tileWidth = renderInfo.tileSize.width(); - const float tileHeight = renderInfo.tileSize.height(); - - glBindTexture(GL_TEXTURE_2D, renderInfo.textureInfo->m_textureId); - - // setup the texture if needed - if (renderInfo.textureInfo->m_width != tileWidth - || renderInfo.textureInfo->m_height != tileHeight) { - - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tileWidth, tileHeight, - 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); - renderInfo.textureInfo->m_width = tileWidth; - renderInfo.textureInfo->m_height = tileHeight; - - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - } - GaneshContext* ganesh = GaneshContext::instance(); - // TODO only need to reset if others are sharing our context - ganesh->getGrContext()->resetContext(); - SkDevice* device = NULL; - if (tileWidth == TilesManager::tileWidth() && tileHeight == TilesManager::tileHeight()) { - device = ganesh->getDeviceForBaseTile(renderInfo.textureInfo->m_textureId); + if (renderInfo.tileSize.width() == TilesManager::tileWidth() + && renderInfo.tileSize.height() == TilesManager::tileHeight()) { + device = ganesh->getDeviceForBaseTile(renderInfo); } else { // TODO support arbitrary sizes for layers XLOG("ERROR: expected (%d,%d) actual (%d,%d)", TilesManager::tileWidth(), TilesManager::tileHeight(), - tileWidth, tileHeight); + renderInfo.tileSize.width(), renderInfo.tileSize.height()); } if (renderInfo.measurePerf) { @@ -124,8 +104,10 @@ void GaneshRenderer::setupCanvas(const TileRenderInfo& renderInfo, SkCanvas* can canvas->setDevice(device); // invert canvas contents - canvas->scale(SK_Scalar1, -SK_Scalar1); - canvas->translate(0, -SkIntToScalar(renderInfo.tileSize.height())); + if (renderInfo.textureInfo->getSharedTextureMode() == EglImageMode) { + canvas->scale(SK_Scalar1, -SK_Scalar1); + canvas->translate(0, -renderInfo.tileSize.height()); + } } void GaneshRenderer::setupPartialInval(const TileRenderInfo& renderInfo, SkCanvas* canvas) @@ -145,9 +127,15 @@ void GaneshRenderer::renderingComplete(const TileRenderInfo& renderInfo, SkCanva m_perfMon.start(TAG_UPDATE_TEXTURE); } - GaneshContext::instance()->getGrContext()->flush(); + XLOG("rendered to tile (%d,%d)", renderInfo.x, renderInfo.y); + + GaneshContext::instance()->flush(); - //TODO if texture is surfaceTexture then... + // 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 (renderInfo.measurePerf) m_perfMon.stop(TAG_UPDATE_TEXTURE); diff --git a/Source/WebCore/platform/graphics/android/SharedTexture.cpp b/Source/WebCore/platform/graphics/android/SharedTexture.cpp index 4f52107..a7d43b5 100644 --- a/Source/WebCore/platform/graphics/android/SharedTexture.cpp +++ b/Source/WebCore/platform/graphics/android/SharedTexture.cpp @@ -60,11 +60,9 @@ SharedTexture::SharedTexture(SharedTextureMode mode) glGenTextures(1, &m_sourceTexture->m_textureId); m_sourceTexture->m_surfaceTexture = - new android::SurfaceTexture(m_sourceTexture->m_textureId); + new android::SurfaceTexture(m_sourceTexture->m_textureId, false); m_sourceTexture->m_ANW = new android::SurfaceTextureClient(m_sourceTexture->m_surfaceTexture); - - m_sourceTexture->m_surfaceTexture->setSynchronousMode(false); } } diff --git a/Source/WebCore/platform/graphics/android/TextureInfo.cpp b/Source/WebCore/platform/graphics/android/TextureInfo.cpp index 849e6fc..5db1711 100644 --- a/Source/WebCore/platform/graphics/android/TextureInfo.cpp +++ b/Source/WebCore/platform/graphics/android/TextureInfo.cpp @@ -42,6 +42,7 @@ TextureInfo::TextureInfo(SharedTextureMode mode) m_height = 0; m_internalFormat = 0; m_sharedTextureMode = mode; + m_eglSurface = EGL_NO_SURFACE; } bool TextureInfo::equalsAttributes(const TextureInfo* otherTexture) diff --git a/Source/WebCore/platform/graphics/android/TextureInfo.h b/Source/WebCore/platform/graphics/android/TextureInfo.h index 252d288..c1cb1cd 100644 --- a/Source/WebCore/platform/graphics/android/TextureInfo.h +++ b/Source/WebCore/platform/graphics/android/TextureInfo.h @@ -26,6 +26,7 @@ #ifndef TextureInfo_h #define TextureInfo_h +#include <EGL/egl.h> #include <GLES2/gl2.h> #include <jni.h> #include <ui/GraphicBuffer.h> @@ -70,6 +71,9 @@ public: sp<android::SurfaceTexture> m_surfaceTexture; sp<ANativeWindow> m_ANW; + // The EGLSurface wraps the m_ANW to enable direct OpenGL rendering (e.g. Ganesh) + EGLSurface m_eglSurface; + private: SharedTextureMode m_sharedTextureMode; }; diff --git a/Source/WebCore/platform/graphics/android/TilesProfiler.cpp b/Source/WebCore/platform/graphics/android/TilesProfiler.cpp index 466923a..653d525 100644 --- a/Source/WebCore/platform/graphics/android/TilesProfiler.cpp +++ b/Source/WebCore/platform/graphics/android/TilesProfiler.cpp @@ -97,7 +97,7 @@ void TilesProfiler::nextFrame(int left, int top, int right, int bottom, float sc m_records.append(WTF::Vector<TileProfileRecord>()); - //first two records designate viewport + //first record designates viewport m_records.last().append(TileProfileRecord( left, top, right, bottom, scale, true, (int)(timeDelta * 1000))); @@ -105,7 +105,7 @@ void TilesProfiler::nextFrame(int left, int top, int right, int bottom, float sc void TilesProfiler::nextTile(BaseTile& tile, float scale, bool inView) { - if (!m_enabled || (m_records.size() > MAX_PROF_FRAMES)) + if (!m_enabled || (m_records.size() > MAX_PROF_FRAMES) || (m_records.size() == 0)) return; bool isReady = tile.isTileReady(); @@ -128,7 +128,7 @@ void TilesProfiler::nextTile(BaseTile& tile, float scale, bool inView) void TilesProfiler::nextInval(const IntRect& rect, float scale) { - if (!m_enabled || (m_records.size() > MAX_PROF_FRAMES)) + if (!m_enabled || (m_records.size() > MAX_PROF_FRAMES) || (m_records.size() == 0)) return; m_records.last().append(TileProfileRecord( diff --git a/Source/WebCore/rendering/RenderLayer.cpp b/Source/WebCore/rendering/RenderLayer.cpp index 4e1c875..ce5bf27 100644 --- a/Source/WebCore/rendering/RenderLayer.cpp +++ b/Source/WebCore/rendering/RenderLayer.cpp @@ -177,6 +177,9 @@ RenderLayer::RenderLayer(RenderBoxModelObject* renderer) #if USE(ACCELERATED_COMPOSITING) , m_hasCompositingDescendant(false) , m_mustOverlapCompositedLayers(false) +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + , m_shouldComposite(false) +#endif #endif , m_containsDirtyOverlayScrollbars(false) #if ENABLE(ANDROID_OVERFLOW_SCROLL) diff --git a/Source/WebCore/rendering/RenderLayer.h b/Source/WebCore/rendering/RenderLayer.h index 2174920..f257593 100644 --- a/Source/WebCore/rendering/RenderLayer.h +++ b/Source/WebCore/rendering/RenderLayer.h @@ -354,7 +354,7 @@ public: if (hasOverflowScroll()) return true; #endif - return !hasAutoZIndex() || renderer()->isRenderView() || (isComposited() && isFixed()); + return !hasAutoZIndex() || renderer()->isRenderView() || (isComposited() && isFixed()) || m_shouldComposite; } #else #if ENABLE(ANDROID_OVERFLOW_SCROLL) @@ -641,6 +641,10 @@ private: bool mustOverlapCompositedLayers() const { return m_mustOverlapCompositedLayers; } void setMustOverlapCompositedLayers(bool b) { m_mustOverlapCompositedLayers = b; } +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + bool shouldComposite() { return m_shouldComposite; } + void setShouldComposite(bool b) { m_shouldComposite = b; } +#endif #endif void updateContentsScale(float); @@ -743,6 +747,9 @@ protected: #if USE(ACCELERATED_COMPOSITING) bool m_hasCompositingDescendant : 1; // In the z-order tree. bool m_mustOverlapCompositedLayers : 1; +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + bool m_shouldComposite : 1; +#endif #endif bool m_containsDirtyOverlayScrollbars : 1; diff --git a/Source/WebCore/rendering/RenderLayerCompositor.cpp b/Source/WebCore/rendering/RenderLayerCompositor.cpp index 786f806..8d066e9 100644 --- a/Source/WebCore/rendering/RenderLayerCompositor.cpp +++ b/Source/WebCore/rendering/RenderLayerCompositor.cpp @@ -80,6 +80,9 @@ struct CompositingState { #if ENABLE(COMPOSITED_FIXED_ELEMENTS) , m_fixedSibling(false) #endif +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + , m_hasScrollableElement(false) +#endif #ifndef NDEBUG , m_depth(0) #endif @@ -91,6 +94,9 @@ struct CompositingState { #if ENABLE(COMPOSITED_FIXED_ELEMENTS) bool m_fixedSibling; #endif +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + bool m_hasScrollableElement; +#endif #ifndef NDEBUG int m_depth; #endif @@ -288,6 +294,10 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex. CompositingState compState(updateRoot); bool layersChanged = false; + +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + compState.m_hasScrollableElement = false; +#endif if (m_compositingConsultsOverlap) { OverlapMap overlapTestRequestMap; computeCompositingRequirements(updateRoot, &overlapTestRequestMap, compState, layersChanged); @@ -589,14 +599,6 @@ bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, con for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) { const IntRect& bounds = it->second; if (layerBounds.intersects(bounds)) { -#if ENABLE(COMPOSITED_FIXED_ELEMENTS) - RenderLayer* intersectedLayer = it->first; - if (intersectedLayer && intersectedLayer->isFixed()) { - if (bounds.contains(layerBounds)) { - continue; - } - } -#endif return true; } } @@ -604,6 +606,53 @@ bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, con return false; } +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + +// to properly support z-index with composited fixed elements, we need to turn +// layers following a fixed layer into compositing mode; but if a layer is fully +// contained into a previous layer already composited (that is not the fixed +// layer), we don't need to composite it. This saves up quite a bit on the +// number of layers we have to composite. +// +bool RenderLayerCompositor::checkForFixedLayers(Vector<RenderLayer*>* list, bool stopAtFixedLayer) +{ + size_t listSize = list->size(); + int haveFixedLayer = -1; + bool fixedSibling = false; + for (size_t j = 0; j < listSize; ++j) { + RenderLayer* currentLayer = list->at(j); + if (currentLayer->isFixed() && needsToBeComposited(currentLayer)) { + haveFixedLayer = j; + fixedSibling = true; + } + if (haveFixedLayer != -1 && haveFixedLayer != j) { + IntRect currentLayerBounds = currentLayer->renderer()->localToAbsoluteQuad( + FloatRect(currentLayer->localBoundingBox())).enclosingBoundingBox(); + bool needComposite = true; + int stop = 0; + if (stopAtFixedLayer) + stop = haveFixedLayer + 1; + + for (size_t k = j - 1; k >= stop; --k) { + RenderLayer* aLayer = list->at(k); + if (aLayer && aLayer->renderer()) { + IntRect bounds = aLayer->renderer()->localToAbsoluteQuad( + FloatRect(aLayer->localBoundingBox())).enclosingBoundingBox(); + if (bounds.contains(currentLayerBounds) + && needsToBeComposited(aLayer)) { + needComposite = false; + break; + } + } + } + currentLayer->setShouldComposite(needComposite); + } + } + return fixedSibling; +} + +#endif + // Recurse through the layers in z-index and overflow order (which is equivalent to painting order) // For the z-order children of a compositing layer: // If a child layers has a compositing layer, then all subsequent layers must @@ -636,7 +685,14 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O mustOverlapCompositedLayers = overlapsCompositedLayers(*overlapMap, absBounds); } +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + if (compositingState.m_fixedSibling) + layer->setMustOverlapCompositedLayers(layer->shouldComposite()); + else + layer->setMustOverlapCompositedLayers(mustOverlapCompositedLayers); +#else layer->setMustOverlapCompositedLayers(mustOverlapCompositedLayers); +#endif // The children of this layer don't need to composite, unless there is // a compositing layer among them, so start by inheriting the compositing @@ -648,17 +704,20 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O bool willBeComposited = needsToBeComposited(layer); -#if ENABLE(COMPOSITED_FIXED_ELEMENTS) - // If we are a fixed layer, signal it to our siblings - if (willBeComposited && layer->isFixed()) - compositingState.m_fixedSibling = true; - - if (!willBeComposited && compositingState.m_fixedSibling) { - layer->setMustOverlapCompositedLayers(true); - willBeComposited = true; - } +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + // tell the parent it has scrollable descendants. + if (layer->hasOverflowScroll()) + compositingState.m_hasScrollableElement = true; #endif + +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + // we don't want to signal that the subtree is compositing if the reason + // is because the layer is an overflow layer -- doing so would trigger + // all the above layers to be composited unnecessarily + if (willBeComposited && !layer->hasOverflowScroll()) { +#else if (willBeComposited) { +#endif // Tell the parent it has compositing descendants. compositingState.m_subtreeIsCompositing = true; // This layer now acts as the ancestor for kids. @@ -680,25 +739,10 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) - childState.m_fixedSibling = false; - - // For the negative z-order, if we have a fixed layer - // we need to make all the siblings composited layers. - // Otherwise a negative layer (below the fixed layer) could - // still be drawn onto a higher z-order layer (e.g. the body) - // if not immediately intersecting with our fixed layer. - // So it's not enough here to only set m_fixedSibling for - // subsequent siblings as we do for the normal flow - // and positive z-order. - for (size_t j = 0; j < listSize; ++j) { - if ((negZOrderList->at(j))->isFixed() && - needsToBeComposited(negZOrderList->at(j))) { - childState.m_fixedSibling = true; - break; - } - } + childState.m_fixedSibling = compositingState.m_fixedSibling; + if (checkForFixedLayers(negZOrderList, false)) + childState.m_fixedSibling = true; #endif - for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged); @@ -716,12 +760,14 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O } } } - + ASSERT(!layer->m_normalFlowListDirty); if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) - childState.m_fixedSibling = false; + childState.m_fixedSibling = compositingState.m_fixedSibling; + if (checkForFixedLayers(normalFlowList, true)) + childState.m_fixedSibling = true; #endif for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); @@ -733,7 +779,9 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) - childState.m_fixedSibling = false; + childState.m_fixedSibling = compositingState.m_fixedSibling; + if (checkForFixedLayers(posZOrderList, true)) + childState.m_fixedSibling = true; #endif for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); @@ -768,6 +816,11 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O if (childState.m_subtreeIsCompositing) compositingState.m_subtreeIsCompositing = true; +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + if (childState.m_hasScrollableElement) + compositingState.m_hasScrollableElement = true; +#endif + // Set the flag to say that this SC has compositing children. layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing); @@ -781,7 +834,13 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, O // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need // to be composited, then we can drop out of compositing mode altogether. +#if ENABLE(ANDROID_OVERFLOW_SCROLL) + // We also need to check that we don't have a scrollable layer, as this + // would not have set the m_subtreeIsCompositing flag + if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !childState.m_hasScrollableElement && !requiresCompositingLayer(layer) && !m_forceCompositingMode) { +#else if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode) { +#endif enableCompositingMode(false); willBeComposited = false; } diff --git a/Source/WebCore/rendering/RenderLayerCompositor.h b/Source/WebCore/rendering/RenderLayerCompositor.h index 0315050..813e265 100644 --- a/Source/WebCore/rendering/RenderLayerCompositor.h +++ b/Source/WebCore/rendering/RenderLayerCompositor.h @@ -218,6 +218,10 @@ private: void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*); +#if ENABLE(COMPOSITED_FIXED_ELEMENTS) + bool checkForFixedLayers(Vector<RenderLayer*>* list, bool stopAtFixedLayer); +#endif + // Returns true if any layer's compositing changed void computeCompositingRequirements(RenderLayer*, OverlapMap*, struct CompositingState&, bool& layersChanged); |