diff options
Diffstat (limited to 'Source/WebCore/platform')
22 files changed, 282 insertions, 251 deletions
diff --git a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp index 89c0ead..bdd8028 100644 --- a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp +++ b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp @@ -65,14 +65,14 @@ using namespace android; GLWebViewState::GLWebViewState() : m_frameworkLayersInval(0, 0, 0, 0) , m_isScrolling(false) - , m_isViewportScrolling(false) + , m_isVisibleContentRectScrolling(false) , m_goingDown(true) , m_goingLeft(false) , m_scale(1) , m_layersRenderingMode(kAllTextures) , m_surfaceCollectionManager() { - m_viewport.setEmpty(); + m_visibleContentRect.setEmpty(); #ifdef DEBUG_COUNT ClassTracker::instance()->increment("GLWebViewState"); @@ -123,14 +123,16 @@ void GLWebViewState::scrollLayer(int layerId, int x, int y) m_surfaceCollectionManager.updateScrollableLayer(layerId, x, y); } -void GLWebViewState::setViewport(const SkRect& viewport, float scale) +void GLWebViewState::setVisibleContentRect(const SkRect& visibleContentRect, float scale) { - // allocate max possible number of tiles visible with this viewport / expandedTileBounds + // allocate max possible number of tiles visible with this visibleContentRect / expandedTileBounds const float invTileContentWidth = scale / TilesManager::tileWidth(); const float invTileContentHeight = scale / TilesManager::tileHeight(); - int viewMaxTileX = static_cast<int>(ceilf((viewport.width()-1) * invTileContentWidth)) + 1; - int viewMaxTileY = static_cast<int>(ceilf((viewport.height()-1) * invTileContentHeight)) + 1; + int viewMaxTileX = + static_cast<int>(ceilf((visibleContentRect.width()-1) * invTileContentWidth)) + 1; + int viewMaxTileY = + static_cast<int>(ceilf((visibleContentRect.height()-1) * invTileContentHeight)) + 1; TilesManager* tilesManager = TilesManager::instance(); int maxTextureCount = viewMaxTileX * viewMaxTileY * (tilesManager->highEndGfx() ? 4 : 2); @@ -138,24 +140,26 @@ void GLWebViewState::setViewport(const SkRect& viewport, float scale) tilesManager->setCurrentTextureCount(maxTextureCount); // TODO: investigate whether we can move this return earlier. - if ((m_viewport == viewport) + if ((m_visibleContentRect == visibleContentRect) && (m_scale == scale)) { // everything below will stay the same, early return. - m_isViewportScrolling = false; + m_isVisibleContentRectScrolling = false; return; } m_scale = scale; - m_goingDown = m_viewport.fTop - viewport.fTop <= 0; - m_goingLeft = m_viewport.fLeft - viewport.fLeft >= 0; + m_goingDown = m_visibleContentRect.fTop - visibleContentRect.fTop <= 0; + m_goingLeft = m_visibleContentRect.fLeft - visibleContentRect.fLeft >= 0; - // detect viewport scrolling from short programmatic scrolls/jumps - m_isViewportScrolling = m_viewport != viewport && SkRect::Intersects(m_viewport, viewport); - m_viewport = viewport; + // detect visibleContentRect scrolling from short programmatic scrolls/jumps + m_isVisibleContentRectScrolling = m_visibleContentRect != visibleContentRect + && SkRect::Intersects(m_visibleContentRect, visibleContentRect); + m_visibleContentRect = visibleContentRect; - ALOGV("New VIEWPORT %.2f - %.2f %.2f - %.2f (w: %2.f h: %.2f scale: %.2f )", - m_viewport.fLeft, m_viewport.fTop, m_viewport.fRight, m_viewport.fBottom, - m_viewport.width(), m_viewport.height(), scale); + ALOGV("New visibleContentRect %.2f - %.2f %.2f - %.2f (w: %2.f h: %.2f scale: %.2f )", + m_visibleContentRect.fLeft, m_visibleContentRect.fTop, + m_visibleContentRect.fRight, m_visibleContentRect.fBottom, + m_visibleContentRect.width(), m_visibleContentRect.height(), scale); } #ifdef MEASURES_PERF @@ -192,8 +196,9 @@ void GLWebViewState::resetLayersDirtyArea() m_frameworkLayersInval.setHeight(0); } -double GLWebViewState::setupDrawing(const IntRect& viewRect, const SkRect& visibleRect, - const IntRect& webViewRect, int titleBarHeight, +double GLWebViewState::setupDrawing(const IntRect& invScreenRect, + const SkRect& visibleContentRect, + const IntRect& screenRect, int titleBarHeight, const IntRect& screenClip, float scale) { TilesManager* tilesManager = TilesManager::instance(); @@ -212,12 +217,12 @@ double GLWebViewState::setupDrawing(const IntRect& viewRect, const SkRect& visib transferQueue->initGLResources(TilesManager::tileWidth(), TilesManager::tileHeight()); } - shader->setupDrawing(viewRect, visibleRect, webViewRect, + shader->setupDrawing(invScreenRect, visibleContentRect, screenRect, titleBarHeight, screenClip, scale); double currentTime = WTF::currentTime(); - setViewport(visibleRect, scale); + setVisibleContentRect(visibleContentRect, scale); return currentTime; } @@ -287,36 +292,39 @@ bool GLWebViewState::setLayersRenderingMode(TexturesResult& nbTexturesNeeded) return (m_layersRenderingMode != layersRenderingMode && invalBase); } -// -rect(viewRect) is the webViewRect with inverted Y, in screen coordinate. -// -visibleRect is the visible area in document coordinate. -// They are both based on webViewRect and calculated in Java side. +// -invScreenRect is the webView's rect with inverted Y screen coordinate. +// -visibleContentRect is the visible area in content coordinate. +// They are both based on webView's rect and calculated in Java side. // -// -clip is the final glViewport value in screen coordinate, and it contains the -// animation translation/scale and FBO offset. +// -screenClip is in screen coordinate, so we need to invert the Y axis before +// passing into GL functions. Clip can be smaller than the webView's rect. // // TODO: Try to decrease the number of parameters as some info is redundant. -int GLWebViewState::drawGL(IntRect& rect, SkRect& visibleRect, IntRect* invalRect, - IntRect& webViewRect, int titleBarHeight, - IntRect& clip, float scale, +int GLWebViewState::drawGL(IntRect& invScreenRect, SkRect& visibleContentRect, + IntRect* invalRect, IntRect& screenRect, int titleBarHeight, + IntRect& screenClip, float scale, bool* collectionsSwappedPtr, bool* newCollectionHasAnimPtr, bool shouldDraw) { TilesManager* tilesManager = TilesManager::instance(); if (shouldDraw) - tilesManager->getProfiler()->nextFrame(visibleRect.fLeft, visibleRect.fTop, - visibleRect.fRight, visibleRect.fBottom, + tilesManager->getProfiler()->nextFrame(visibleContentRect.fLeft, + visibleContentRect.fTop, + visibleContentRect.fRight, + visibleContentRect.fBottom, scale); tilesManager->incDrawGLCount(); - ALOGV("drawGL, rect/viewRect(%d, %d, %d, %d), visibleRect(%.2f, %.2f, %.2f, %.2f)", - rect.x(), rect.y(), rect.width(), rect.height(), - visibleRect.fLeft, visibleRect.fTop, visibleRect.fRight, visibleRect.fBottom); + ALOGV("drawGL, invScreenRect(%d, %d, %d, %d), visibleContentRect(%.2f, %.2f, %.2f, %.2f)", + invScreenRect.x(), invScreenRect.y(), invScreenRect.width(), invScreenRect.height(), + visibleContentRect.fLeft, visibleContentRect.fTop, + visibleContentRect.fRight, visibleContentRect.fBottom); - ALOGV("drawGL, invalRect(%d, %d, %d, %d), webViewRect(%d, %d, %d, %d)" - "clip/glViewport (%d, %d, %d, %d), scale %f titleBarHeight %d", + ALOGV("drawGL, invalRect(%d, %d, %d, %d), screenRect(%d, %d, %d, %d)" + "screenClip (%d, %d, %d, %d), scale %f titleBarHeight %d", invalRect->x(), invalRect->y(), invalRect->width(), invalRect->height(), - webViewRect.x(), webViewRect.y(), webViewRect.width(), webViewRect.height(), - clip.x(), clip.y(), clip.width(), clip.height(), scale, titleBarHeight); + screenRect.x(), screenRect.y(), screenRect.width(), screenRect.height(), + screenClip.x(), screenClip.y(), screenClip.width(), screenClip.height(), scale, titleBarHeight); resetLayersDirtyArea(); @@ -340,14 +348,17 @@ int GLWebViewState::drawGL(IntRect& rect, SkRect& visibleRect, IntRect* invalRec // gather the textures we can use tilesManager->gatherTextures(); - double currentTime = setupDrawing(rect, visibleRect, webViewRect, titleBarHeight, clip, scale); + double currentTime = setupDrawing(invScreenRect, visibleContentRect, screenRect, + titleBarHeight, screenClip, scale); TexturesResult nbTexturesNeeded; bool fastSwap = isScrolling() || m_layersRenderingMode == kSingleSurfaceRendering; - m_glExtras.setViewport(visibleRect); - returnFlags |= m_surfaceCollectionManager.drawGL(currentTime, rect, visibleRect, + m_glExtras.setVisibleContentRect(visibleContentRect); + returnFlags |= m_surfaceCollectionManager.drawGL(currentTime, invScreenRect, + visibleContentRect, scale, fastSwap, - collectionsSwappedPtr, newCollectionHasAnimPtr, + collectionsSwappedPtr, + newCollectionHasAnimPtr, &nbTexturesNeeded, shouldDraw); int nbTexturesForImages = ImagesManager::instance()->nbTextures(); @@ -380,7 +391,7 @@ int GLWebViewState::drawGL(IntRect& rect, SkRect& visibleRect, IntRect* invalRec ALOGV("invalRect(%d, %d, %d, %d)", inval.x(), inval.y(), inval.width(), inval.height()); - if (!invalRect->intersects(rect)) { + if (!invalRect->intersects(invScreenRect)) { // invalidate is occurring offscreen, do full inval to guarantee redraw fullScreenInval = true; } @@ -395,7 +406,7 @@ int GLWebViewState::drawGL(IntRect& rect, SkRect& visibleRect, IntRect* invalRec } if (shouldDraw) - showFrameInfo(rect, *collectionsSwappedPtr); + showFrameInfo(invScreenRect, *collectionsSwappedPtr); return returnFlags; } diff --git a/Source/WebCore/platform/graphics/android/GLWebViewState.h b/Source/WebCore/platform/graphics/android/GLWebViewState.h index 8d0f214..7892e83 100644 --- a/Source/WebCore/platform/graphics/android/GLWebViewState.h +++ b/Source/WebCore/platform/graphics/android/GLWebViewState.h @@ -75,7 +75,7 @@ class TexturesResult; // // The rendering model is to use tiles to display the BaseLayer (as obviously a // BaseLayer's area can be arbitrarly large). The idea is to compute a set of -// tiles covering the viewport's area, paint those tiles using the webview's +// tiles covering the visibleContentRect's area, paint those tiles using the webview's // content (i.e. the BaseLayer's PictureSet), then display those tiles. // We check which tile we should use at every frame. // @@ -86,7 +86,7 @@ class TexturesResult; // the BaseLayer's surface. When drawing, we ask the TiledPage to prepare() // itself then draw itself on screen. The prepare() function is the one // that schedules tiles to be painted -- i.e. the subset of tiles that intersect -// with the current viewport. When they are ready, we can display +// with the current visibleContentRect. When they are ready, we can display // the TiledPage. // // Note that BaseLayerAndroid::drawGL() will return true to the java side if @@ -102,7 +102,7 @@ class TexturesResult; // accordingly (and therefore possible loss of quality): this is fast as it's // purely a hardware operation. When the user is done zooming, we ask for // TiledPage B to be painted at the new scale factor, covering the -// viewport's area. When B is ready, we swap it with A. +// visibleContentRect's area. When B is ready, we swap it with A. // // Texture allocation // ------------------ @@ -111,17 +111,17 @@ class TexturesResult; // get the GL textures from an existing pool, and reuse them. // // The way we do it is that when we call TiledPage::prepare(), we group the -// tiles we need (i.e. in the viewport and dirty) into a TilesSet and call +// tiles we need (i.e. in the visibleContentRect and dirty) into a TilesSet and call // Tile::reserveTexture() for each tile (which ensures there is a specific // GL textures backing the Tiles). // // reserveTexture() will ask the TilesManager for a texture. The allocation // mechanism goal is to (in order): // - prefers to allocate the same texture as the previous time -// - prefers to allocate textures that are as far from the viewport as possible +// - prefers to allocate textures that are as far from the visibleContentRect as possible // - prefers to allocate textures that are used by different TiledPages // -// Note that to compute the distance of each tile from the viewport, each time +// Note that to compute the distance of each tile from the visibleContentRect, each time // we prepare() a TiledPage. Also during each prepare() we compute which tiles // are dirty based on the info we have received from webkit. // @@ -173,12 +173,12 @@ public: GLExtras* glExtras() { return &m_glExtras; } void setIsScrolling(bool isScrolling) { m_isScrolling = isScrolling; } - bool isScrolling() { return m_isScrolling || m_isViewportScrolling; } + bool isScrolling() { return m_isScrolling || m_isVisibleContentRectScrolling; } bool setLayersRenderingMode(TexturesResult&); - int drawGL(IntRect& rect, SkRect& visibleRect, IntRect* invalRect, - IntRect& webViewRect, int titleBarHeight, + int drawGL(IntRect& rect, SkRect& visibleContentRect, IntRect* invalRect, + IntRect& screenRect, int titleBarHeight, IntRect& clip, float scale, bool* collectionsSwappedPtr, bool* newCollectionHasAnimPtr, bool shouldDraw); @@ -208,16 +208,16 @@ public: void scrollLayer(int layerId, int x, int y); private: - void setViewport(const SkRect& viewport, float scale); - double setupDrawing(const IntRect& viewRect, const SkRect& visibleRect, - const IntRect& webViewRect, int titleBarHeight, + void setVisibleContentRect(const SkRect& visibleContentRect, float scale); + double setupDrawing(const IntRect& invScreenRect, const SkRect& visibleContentRect, + const IntRect& screenRect, int titleBarHeight, const IntRect& screenClip, float scale); void showFrameInfo(const IntRect& rect, bool collectionsSwapped); void clearRectWithColor(const IntRect& rect, float r, float g, float b, float a); double m_prevDrawTime; - SkRect m_viewport; + SkRect m_visibleContentRect; IntRect m_frameworkLayersInval; #ifdef MEASURES_PERF @@ -229,7 +229,7 @@ private: GLExtras m_glExtras; bool m_isScrolling; - bool m_isViewportScrolling; + bool m_isVisibleContentRectScrolling; bool m_goingDown; bool m_goingLeft; diff --git a/Source/WebCore/platform/graphics/android/layers/CanvasLayer.cpp b/Source/WebCore/platform/graphics/android/layers/CanvasLayer.cpp index 1813903..40332d0 100644 --- a/Source/WebCore/platform/graphics/android/layers/CanvasLayer.cpp +++ b/Source/WebCore/platform/graphics/android/layers/CanvasLayer.cpp @@ -63,13 +63,13 @@ CanvasLayer::CanvasLayer(const CanvasLayer& layer) if (!layer.m_canvas) { // The canvas has already been destroyed - this shouldn't happen ALOGW("Creating a CanvasLayer for a destroyed canvas!"); - m_contentRect = IntRect(); + m_visibleContentRect = IntRect(); m_offsetFromRenderer = IntSize(); m_texture->setHwAccelerated(false); return; } // We are making a copy for the UI, sync the interesting bits - m_contentRect = layer.contentRect(); + m_visibleContentRect = layer.visibleContentRect(); m_offsetFromRenderer = layer.offsetFromRenderer(); bool previousState = m_texture->hasValidTexture(); if (!previousState && layer.m_dirtyCanvas.isEmpty()) { @@ -86,7 +86,7 @@ CanvasLayer::CanvasLayer(const CanvasLayer& layer) // Merge the canvas invals with the layer's invals to repaint the needed // tiles. SkRegion::Iterator iter(layer.m_dirtyCanvas); - const IntPoint& offset = m_contentRect.location(); + const IntPoint& offset = m_visibleContentRect.location(); for (; !iter.done(); iter.next()) { SkIRect diff = iter.rect(); diff.fLeft += offset.x(); @@ -98,8 +98,8 @@ CanvasLayer::CanvasLayer(const CanvasLayer& layer) } if (previousState != m_texture->hasValidTexture()) { // Need to do a full inval of the canvas content as we are mode switching - m_dirtyRegion.op(m_contentRect.x(), m_contentRect.y(), - m_contentRect.maxX(), m_contentRect.maxY(), SkRegion::kUnion_Op); + m_dirtyRegion.op(m_visibleContentRect.x(), m_visibleContentRect.y(), + m_visibleContentRect.maxX(), m_visibleContentRect.maxY(), SkRegion::kUnion_Op); } } } @@ -160,7 +160,7 @@ SkBitmapRef* CanvasLayer::bitmap() const return m_canvas->copiedImage()->nativeImageForCurrentFrame(); } -IntRect CanvasLayer::contentRect() const +IntRect CanvasLayer::visibleContentRect() const { if (!m_canvas || !m_canvas->renderer() @@ -187,9 +187,9 @@ void CanvasLayer::contentDraw(SkCanvas* canvas, PaintStyle style) if (!m_bitmap) return; SkBitmap& bitmap = m_bitmap->bitmap(); - SkRect dst = SkRect::MakeXYWH(m_contentRect.x() - m_offsetFromRenderer.width(), - m_contentRect.y() - m_offsetFromRenderer.height(), - m_contentRect.width(), m_contentRect.height()); + SkRect dst = SkRect::MakeXYWH(m_visibleContentRect.x() - m_offsetFromRenderer.width(), + m_visibleContentRect.y() - m_offsetFromRenderer.height(), + m_visibleContentRect.width(), m_visibleContentRect.height()); canvas->drawBitmapRect(bitmap, 0, dst, 0); } @@ -198,9 +198,9 @@ bool CanvasLayer::drawGL(bool layerTilesDisabled) bool ret = LayerAndroid::drawGL(layerTilesDisabled); m_texture->requireTexture(); if (!m_bitmap && m_texture->updateTexImage()) { - SkRect rect = SkRect::MakeXYWH(m_contentRect.x() - m_offsetFromRenderer.width(), - m_contentRect.y() - m_offsetFromRenderer.height(), - m_contentRect.width(), m_contentRect.height()); + SkRect rect = SkRect::MakeXYWH(m_visibleContentRect.x() - m_offsetFromRenderer.width(), + m_visibleContentRect.y() - m_offsetFromRenderer.height(), + m_visibleContentRect.width(), m_visibleContentRect.height()); TextureQuadData data(m_texture->texture(), GL_TEXTURE_EXTERNAL_OES, GL_LINEAR, LayerQuad, &m_drawTransform, &rect); TilesManager::instance()->shader()->drawQuad(&data); diff --git a/Source/WebCore/platform/graphics/android/layers/CanvasLayer.h b/Source/WebCore/platform/graphics/android/layers/CanvasLayer.h index 532dbf2..2bfed1e 100644 --- a/Source/WebCore/platform/graphics/android/layers/CanvasLayer.h +++ b/Source/WebCore/platform/graphics/android/layers/CanvasLayer.h @@ -63,11 +63,11 @@ private: void init(); SkBitmapRef* bitmap() const; - IntRect contentRect() const; + IntRect visibleContentRect() const; IntSize offsetFromRenderer() const; HTMLCanvasElement* m_canvas; - IntRect m_contentRect; + IntRect m_visibleContentRect; IntSize m_offsetFromRenderer; SkRegion m_dirtyCanvas; SkBitmapRef* m_bitmap; diff --git a/Source/WebCore/platform/graphics/android/layers/LayerAndroid.cpp b/Source/WebCore/platform/graphics/android/layers/LayerAndroid.cpp index 535d211..f0d83ac 100644 --- a/Source/WebCore/platform/graphics/android/layers/LayerAndroid.cpp +++ b/Source/WebCore/platform/graphics/android/layers/LayerAndroid.cpp @@ -249,9 +249,12 @@ void LayerAndroid::addDirtyArea() { IntSize layerSize(getSize().width(), getSize().height()); - FloatRect area = TilesManager::instance()->shader()->rectInInvScreenCoord(m_drawTransform, layerSize); - FloatRect clippingRect = TilesManager::instance()->shader()->rectInScreenCoord(m_clippingRect); - FloatRect clip = TilesManager::instance()->shader()->convertScreenCoordToInvScreenCoord(clippingRect); + FloatRect area = + TilesManager::instance()->shader()->rectInViewCoord(m_drawTransform, layerSize); + FloatRect clippingRect = + TilesManager::instance()->shader()->rectInInvViewCoord(m_clippingRect); + FloatRect clip = + TilesManager::instance()->shader()->convertInvViewCoordToViewCoord(clippingRect); area.intersect(clip); IntRect dirtyArea(area.x(), area.y(), area.width(), area.height()); @@ -410,7 +413,8 @@ void LayerAndroid::updatePositions() } void LayerAndroid::updateGLPositionsAndScale(const TransformationMatrix& parentMatrix, - const FloatRect& clipping, float opacity, float scale) + const FloatRect& clipping, float opacity, + float scale) { IntSize layerSize(getSize().width(), getSize().height()); FloatPoint anchorPoint(getAnchorPoint().fX, getAnchorPoint().fY); @@ -441,7 +445,9 @@ void LayerAndroid::updateGLPositionsAndScale(const TransformationMatrix& parentM m_drawTransform.setM42(desiredContentY); } - m_zValue = TilesManager::instance()->shader()->zValue(m_drawTransform, getSize().width(), getSize().height()); + m_zValue = TilesManager::instance()->shader()->zValue(m_drawTransform, + getSize().width(), + getSize().height()); m_atomicSync.lock(); m_scale = scale; @@ -451,7 +457,8 @@ void LayerAndroid::updateGLPositionsAndScale(const TransformationMatrix& parentM setDrawOpacity(opacity); if (m_haveClip) { - // The clipping rect calculation and intersetion will be done in documents coordinates. + // The clipping rect calculation and intersetion will be done in content + // coordinates. FloatRect rect(0, 0, layerSize.width(), layerSize.height()); FloatRect clip = m_drawTransform.mapRect(rect); clip.intersect(clipping); @@ -461,7 +468,8 @@ void LayerAndroid::updateGLPositionsAndScale(const TransformationMatrix& parentM } ALOGV("%s - %d %f %f %f %f", subclassType() == BaseLayer ? "BASE" : "nonbase", - m_haveClip, m_clippingRect.x(), m_clippingRect.y(), m_clippingRect.width(), m_clippingRect.height()); + m_haveClip, m_clippingRect.x(), m_clippingRect.y(), + m_clippingRect.width(), m_clippingRect.height()); if (!m_backfaceVisibility && m_drawTransform.inverse().m33() < 0) { @@ -548,7 +556,7 @@ IntRect LayerAndroid::clippedRect() const { IntRect r(0, 0, getWidth(), getHeight()); IntRect tr = m_drawTransform.mapRect(r); - IntRect cr = TilesManager::instance()->shader()->clippedRectWithViewport(tr); + IntRect cr = TilesManager::instance()->shader()->clippedRectWithVisibleContentRect(tr); IntRect rect = m_drawTransform.inverse().mapRect(cr); return rect; } @@ -582,20 +590,21 @@ void LayerAndroid::showLayer(int indent) if (!indent) { ALOGD("\n\n--- LAYERS TREE ---"); - IntRect documentViewport(TilesManager::instance()->shader()->documentViewport()); - ALOGD("documentViewport(%d, %d, %d, %d)", - documentViewport.x(), documentViewport.y(), - documentViewport.width(), documentViewport.height()); + IntRect contentViewport(TilesManager::instance()->shader()->contentViewport()); + ALOGD("contentViewport(%d, %d, %d, %d)", + contentViewport.x(), contentViewport.y(), + contentViewport.width(), contentViewport.height()); } IntRect r(0, 0, getWidth(), getHeight()); IntRect tr = m_drawTransform.mapRect(r); - IntRect visible = visibleArea(); + IntRect visible = visibleContentArea(); IntRect clip(m_clippingRect.x(), m_clippingRect.y(), m_clippingRect.width(), m_clippingRect.height()); ALOGD("%s %s %s (%d) [%d:0x%x] - %s %s - area (%d, %d, %d, %d) - visible (%d, %d, %d, %d) " "clip (%d, %d, %d, %d) %s %s m_content(%x), pic w: %d h: %d", - spaces, m_haveClip ? "CLIP LAYER" : "", subclassName().ascii().data(), subclassType(), uniqueId(), m_owningLayer, + spaces, m_haveClip ? "CLIP LAYER" : "", subclassName().ascii().data(), + subclassType(), uniqueId(), m_owningLayer, needsTexture() ? "needs a texture" : "no texture", m_imageCRC ? "has an image" : "no image", tr.x(), tr.y(), tr.width(), tr.height(), @@ -750,7 +759,7 @@ int LayerAndroid::setHwAccelerated(bool hwAccelerated) return flags | onSetHwAccelerated(hwAccelerated); } -IntRect LayerAndroid::unclippedArea() +IntRect LayerAndroid::fullContentArea() { IntRect area; area.setX(0); @@ -760,13 +769,13 @@ IntRect LayerAndroid::unclippedArea() return area; } -IntRect LayerAndroid::visibleArea() +IntRect LayerAndroid::visibleContentArea() { - IntRect area = unclippedArea(); + IntRect area = fullContentArea(); if (subclassType() == LayerAndroid::FixedBackgroundBaseLayer) return area; // First, we get the transformed area of the layer, - // in document coordinates + // in content coordinates IntRect rect = m_drawTransform.mapRect(area); int dx = rect.x(); int dy = rect.y(); @@ -775,9 +784,9 @@ IntRect LayerAndroid::visibleArea() IntRect clip(m_clippingRect); rect.intersect(clip); - // Now clip with the viewport in documents coordinate - IntRect documentViewport(TilesManager::instance()->shader()->documentViewport()); - rect.intersect(documentViewport); + // Now clip with the viewport in content coordinate + IntRect contentViewport(TilesManager::instance()->shader()->contentViewport()); + rect.intersect(contentViewport); // Finally, let's return the visible area, in layers coordinate rect.move(-dx, -dy); diff --git a/Source/WebCore/platform/graphics/android/layers/LayerAndroid.h b/Source/WebCore/platform/graphics/android/layers/LayerAndroid.h index ca833f7..170ef41 100644 --- a/Source/WebCore/platform/graphics/android/layers/LayerAndroid.h +++ b/Source/WebCore/platform/graphics/android/layers/LayerAndroid.h @@ -140,8 +140,8 @@ public: IntRect clippedRect() const; bool outsideViewport(); - IntRect unclippedArea(); - IntRect visibleArea(); + IntRect fullContentArea(); + IntRect visibleContentArea(); virtual bool needsTexture(); diff --git a/Source/WebCore/platform/graphics/android/layers/MediaLayer.cpp b/Source/WebCore/platform/graphics/android/layers/MediaLayer.cpp index 6227ea4..7a3730b 100644 --- a/Source/WebCore/platform/graphics/android/layers/MediaLayer.cpp +++ b/Source/WebCore/platform/graphics/android/layers/MediaLayer.cpp @@ -56,7 +56,7 @@ MediaLayer::~MediaLayer() bool MediaLayer::drawGL(bool layerTilesDisabled) { - FloatRect clippingRect = TilesManager::instance()->shader()->rectInScreenCoord(drawClip()); + FloatRect clippingRect = TilesManager::instance()->shader()->rectInInvViewCoord(drawClip()); TilesManager::instance()->shader()->clip(clippingRect); // when the plugin gains focus webkit applies an outline to the diff --git a/Source/WebCore/platform/graphics/android/rendering/GLExtras.cpp b/Source/WebCore/platform/graphics/android/rendering/GLExtras.cpp index 6498ecf..2c114d6 100644 --- a/Source/WebCore/platform/graphics/android/rendering/GLExtras.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/GLExtras.cpp @@ -42,7 +42,7 @@ GLExtras::GLExtras() : m_drawExtra(0) - , m_viewport() + , m_visibleContentRect() { } diff --git a/Source/WebCore/platform/graphics/android/rendering/GLExtras.h b/Source/WebCore/platform/graphics/android/rendering/GLExtras.h index 59a7c3c..e9f697a 100644 --- a/Source/WebCore/platform/graphics/android/rendering/GLExtras.h +++ b/Source/WebCore/platform/graphics/android/rendering/GLExtras.h @@ -43,7 +43,10 @@ public: void drawGL(const LayerAndroid* layer); void setDrawExtra(android::DrawExtra* extra) { m_drawExtra = extra; } - void setViewport(const SkRect & viewport) { m_viewport = viewport; } + void setVisibleContentRect(const SkRect & visibleContentRect) + { + m_visibleContentRect = visibleContentRect; + } void drawRegion(const SkRegion& region, bool fill, bool drawBorder, const TransformationMatrix* drawMat, Color color = COLOR_HOLO_LIGHT); @@ -52,7 +55,7 @@ private: void drawRing(SkRect& srcRect, Color color, const TransformationMatrix* drawMat); android::DrawExtra* m_drawExtra; - SkRect m_viewport; + SkRect m_visibleContentRect; }; } // namespace WebCore diff --git a/Source/WebCore/platform/graphics/android/rendering/ImageTexture.cpp b/Source/WebCore/platform/graphics/android/rendering/ImageTexture.cpp index 6e4a82c..5098b4b 100644 --- a/Source/WebCore/platform/graphics/android/rendering/ImageTexture.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/ImageTexture.cpp @@ -150,8 +150,8 @@ int ImageTexture::nbTextures() // TODO: take in account the visible clip (need to maintain // a list of the clients layer, etc.) - IntRect visibleArea(0, 0, m_image->width(), m_image->height()); - int nbTextures = m_tileGrid->nbTextures(visibleArea, 1.0); + IntRect visibleContentArea(0, 0, m_image->width(), m_image->height()); + int nbTextures = m_tileGrid->nbTextures(visibleContentArea, 1.0); ALOGV("ImageTexture %p, %d x %d needs %d textures", this, m_image->width(), m_image->height(), nbTextures); @@ -184,8 +184,8 @@ bool ImageTexture::prepareGL(GLWebViewState* state) if (!m_tileGrid) return false; - IntRect unclippedArea(0, 0, m_image->width(), m_image->height()); - m_tileGrid->prepareGL(state, 1.0, unclippedArea, unclippedArea, this); + IntRect fullContentArea(0, 0, m_image->width(), m_image->height()); + m_tileGrid->prepareGL(state, 1.0, fullContentArea, fullContentArea, this); if (m_tileGrid->isReady()) { m_tileGrid->swapTiles(); return false; @@ -198,7 +198,7 @@ const TransformationMatrix* ImageTexture::transform() if (!m_layer) return 0; - IntRect layerArea = m_layer->unclippedArea(); + IntRect layerArea = m_layer->fullContentArea(); float scaleW = static_cast<float>(layerArea.width()) / static_cast<float>(m_image->width()); float scaleH = static_cast<float>(layerArea.height()) / static_cast<float>(m_image->height()); TransformationMatrix d = *(m_layer->drawTransform()); @@ -239,8 +239,8 @@ void ImageTexture::drawGL(LayerAndroid* layer, float opacity) // transform and opacity, so we need to set m_layer m_layer = layer; if (m_tileGrid) { - IntRect visibleArea = m_layer->visibleArea(); - m_tileGrid->drawGL(visibleArea, opacity, transform()); + IntRect visibleContentArea = m_layer->visibleContentArea(); + m_tileGrid->drawGL(visibleContentArea, opacity, transform()); } m_layer = 0; } diff --git a/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.cpp b/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.cpp index 423947f..70a1afe 100644 --- a/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.cpp @@ -370,37 +370,46 @@ void ShaderProgram::setBlendingState(bool enableBlending) // Drawing ///////////////////////////////////////////////////////////////////////////////////////// -// We have multiple coordinates to deal with, each could be inverted Y or not, and -// each could be local to webview or global to the screen. -// viewRect - global screen coordinates starting from lower left. -// visibleRect - local document coordinates starting from upper left. -// webViewRect - inverted global screen coordinates starting from upper left. -// screenClip - inverted global screen coordinates starting from upper left. +// We have multiple coordinates to deal with: first is the screen coordinates, +// second is the view coordinates and the last one is content(document) coordinates. +// Both screen and view coordinates are in pixels. +// All these coordinates start from upper left, but for the purpose of OpenGL +// operations, we may need a inverted Y version of such coordinates which +// start from lower left. +// +// invScreenRect - inv screen coordinates starting from lower left. +// visibleContentRect - local content(document) coordinates starting from upper left. +// screenRect - screen coordinates starting from upper left. +// screenClip - screen coordinates starting from upper left. // ------------------------------------------ -// |(origin of inv global screen) | +// |(origin of screen) | // |screen | // | --------------------------------- | -// | | (origin of inv local screen) | | +// | | (origin of view) | | // | | webview | | // | | -------- | | // | | | clip | | | // | | | | | | // | | -------- | | // | | | | -// | |(origin of local screen) | | +// | |(origin of inv view) | | // | --------------------------------- | -// |(origin of global screen) | +// |(origin of inv screen) | // ------------------------------------------ -void ShaderProgram::setupDrawing(const IntRect& viewRect, const SkRect& visibleRect, - const IntRect& webViewRect, int titleBarHeight, +void ShaderProgram::setupDrawing(const IntRect& invScreenRect, + const SkRect& visibleContentRect, + const IntRect& screenRect, int titleBarHeight, const IntRect& screenClip, float scale) { - m_webViewRect = webViewRect; + m_screenRect = screenRect; m_titleBarHeight = titleBarHeight; //// viewport //// - GLUtils::setOrthographicMatrix(m_visibleRectProjectionMatrix, visibleRect.fLeft, - visibleRect.fTop, visibleRect.fRight, visibleRect.fBottom, + GLUtils::setOrthographicMatrix(m_visibleContentRectProjectionMatrix, + visibleContentRect.fLeft, + visibleContentRect.fTop, + visibleContentRect.fRight, + visibleContentRect.fBottom, -1000, 1000); ALOGV("set m_clipProjectionMatrix, %d, %d, %d, %d", @@ -408,7 +417,7 @@ void ShaderProgram::setupDrawing(const IntRect& viewRect, const SkRect& visibleR screenClip.y() + screenClip.height()); // In order to incorporate the animation delta X and Y, using the clip as - // the GL viewport can save all the trouble of re-position from webViewRect + // the GL viewport can save all the trouble of re-position from screenRect // to final position. GLUtils::setOrthographicMatrix(m_clipProjectionMatrix, screenClip.x(), screenClip.y(), screenClip.x() + screenClip.width(), @@ -417,48 +426,45 @@ void ShaderProgram::setupDrawing(const IntRect& viewRect, const SkRect& visibleR glViewport(screenClip.x(), m_targetHeight - screenClip.y() - screenClip.height() , screenClip.width(), screenClip.height()); - m_viewport = visibleRect; + m_visibleContentRect = visibleContentRect; m_currentScale = scale; //// viewRect //// - m_viewRect = viewRect; - - // The following matrices transform document coordinates into screen coordinates - // and inv screen coordinates, and they are local to the webview in terms of - // coordinate origins. - // Note that GLUtils::setOrthographicMatrix is inverting the Y. So screen - // coordinates is starting from lower left, and inverted screen coordinates - // is from upper left. + m_invScreenRect = invScreenRect; + + // The following matrices transform content coordinates into view coordinates + // and inv view coordinates. + // Note that GLUtils::setOrthographicMatrix is inverting the Y. TransformationMatrix viewTranslate; viewTranslate.translate(1.0, 1.0); TransformationMatrix viewScale; - viewScale.scale3d(m_viewRect.width() * 0.5f, m_viewRect.height() * 0.5f, 1); + viewScale.scale3d(m_invScreenRect.width() * 0.5f, m_invScreenRect.height() * 0.5f, 1); - m_documentToScreenMatrix = viewScale * viewTranslate * m_visibleRectProjectionMatrix; + m_contentToInvViewMatrix = viewScale * viewTranslate * m_visibleContentRectProjectionMatrix; viewTranslate.scale3d(1, -1, 1); - m_documentToInvScreenMatrix = viewScale * viewTranslate * m_visibleRectProjectionMatrix; + m_contentToViewMatrix = viewScale * viewTranslate * m_visibleContentRectProjectionMatrix; - IntRect rect(0, 0, m_webViewRect.width(), m_webViewRect.height()); - m_documentViewport = m_documentToScreenMatrix.inverse().mapRect(rect); + IntRect invViewRect(0, 0, m_screenRect.width(), m_screenRect.height()); + m_contentViewport = m_contentToInvViewMatrix.inverse().mapRect(invViewRect); //// clipping //// - IntRect mclip = screenClip; + IntRect viewClip = screenClip; - // The incoming screenClip is in inverted global screen coordinates, we first - // translate it into inverted local screen coordinates. - // Then we convert it into local screen coordinates. + // The incoming screenClip is in screen coordinates, we first + // translate it into view coordinates. + // Then we convert it into inverted view coordinates. // Therefore, in the clip() function, we need to convert things back from - // local screen coordinates to global screen coordinates. - mclip.setX(screenClip.x() - m_webViewRect.x()); - mclip.setY(screenClip.y() - m_webViewRect.y() - m_titleBarHeight); - FloatRect tclip = convertInvScreenCoordToScreenCoord(mclip); - m_screenClip.setLocation(IntPoint(tclip.x(), tclip.y())); + // inverted view coordinates to inverted screen coordinates which is used by GL. + viewClip.setX(screenClip.x() - m_screenRect.x()); + viewClip.setY(screenClip.y() - m_screenRect.y() - m_titleBarHeight); + FloatRect invViewClip = convertViewCoordToInvViewCoord(viewClip); + m_invViewClip.setLocation(IntPoint(invViewClip.x(), invViewClip.y())); // use ceilf to handle view -> doc -> view coord rounding errors - m_screenClip.setSize(IntSize(ceilf(tclip.width()), ceilf(tclip.height()))); + m_invViewClip.setSize(IntSize(ceilf(invViewClip.width()), ceilf(invViewClip.height()))); resetBlending(); @@ -509,47 +515,47 @@ ShaderType ShaderProgram::getTextureShaderType(GLenum textureTarget) } // This function transform a clip rect extracted from the current layer -// into a clip rect in screen coordinates -- used by the clipping rects -FloatRect ShaderProgram::rectInScreenCoord(const TransformationMatrix& drawMatrix, const IntSize& size) +// into a clip rect in InvView coordinates -- used by the clipping rects +FloatRect ShaderProgram::rectInInvViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size) { FloatRect srect(0, 0, size.width(), size.height()); - TransformationMatrix renderMatrix = m_documentToScreenMatrix * drawMatrix; + TransformationMatrix renderMatrix = m_contentToInvViewMatrix * drawMatrix; return renderMatrix.mapRect(srect); } // used by the partial screen invals -FloatRect ShaderProgram::rectInInvScreenCoord(const TransformationMatrix& drawMatrix, const IntSize& size) +FloatRect ShaderProgram::rectInViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size) { FloatRect srect(0, 0, size.width(), size.height()); - TransformationMatrix renderMatrix = m_documentToInvScreenMatrix * drawMatrix; + TransformationMatrix renderMatrix = m_contentToViewMatrix * drawMatrix; return renderMatrix.mapRect(srect); } -FloatRect ShaderProgram::rectInInvScreenCoord(const FloatRect& rect) +FloatRect ShaderProgram::rectInViewCoord(const FloatRect& rect) { - return m_documentToInvScreenMatrix.mapRect(rect); + return m_contentToViewMatrix.mapRect(rect); } -FloatRect ShaderProgram::rectInScreenCoord(const FloatRect& rect) +FloatRect ShaderProgram::rectInInvViewCoord(const FloatRect& rect) { - return m_documentToScreenMatrix.mapRect(rect); + return m_contentToInvViewMatrix.mapRect(rect); } -FloatRect ShaderProgram::convertScreenCoordToDocumentCoord(const FloatRect& rect) +FloatRect ShaderProgram::convertInvViewCoordToContentCoord(const FloatRect& rect) { - return m_documentToScreenMatrix.inverse().mapRect(rect); + return m_contentToInvViewMatrix.inverse().mapRect(rect); } -FloatRect ShaderProgram::convertInvScreenCoordToScreenCoord(const FloatRect& rect) +FloatRect ShaderProgram::convertViewCoordToInvViewCoord(const FloatRect& rect) { - FloatRect documentRect = m_documentToInvScreenMatrix.inverse().mapRect(rect); - return rectInScreenCoord(documentRect); + FloatRect visibleContentRect = m_contentToViewMatrix.inverse().mapRect(rect); + return rectInInvViewCoord(visibleContentRect); } -FloatRect ShaderProgram::convertScreenCoordToInvScreenCoord(const FloatRect& rect) +FloatRect ShaderProgram::convertInvViewCoordToViewCoord(const FloatRect& rect) { - FloatRect documentRect = m_documentToScreenMatrix.inverse().mapRect(rect); - return rectInInvScreenCoord(documentRect); + FloatRect visibleContentRect = m_contentToInvViewMatrix.inverse().mapRect(rect); + return rectInViewCoord(visibleContentRect); } // clip is in screen coordinates @@ -568,14 +574,14 @@ void ShaderProgram::clip(const FloatRect& clip) clip.y(), clip.width(), clip.height()); - if (!m_screenClip.isEmpty()) - screenClip.intersect(m_screenClip); + if (!m_invViewClip.isEmpty()) + screenClip.intersect(m_invViewClip); // The previous intersection calculation is using local screen coordinates. // Now we need to convert things from local screen coordinates to global // screen coordinates and pass to the GL functions. - screenClip.setX(screenClip.x() + m_viewRect.x()); - screenClip.setY(screenClip.y() + m_viewRect.y()); + screenClip.setX(screenClip.x() + m_invScreenRect.x()); + screenClip.setY(screenClip.y() + m_invScreenRect.y()); if (screenClip.x() < 0) { int w = screenClip.width(); w += screenClip.x(); @@ -594,10 +600,11 @@ void ShaderProgram::clip(const FloatRect& clip) m_clipRect = clip; } -IntRect ShaderProgram::clippedRectWithViewport(const IntRect& rect, int margin) +IntRect ShaderProgram::clippedRectWithVisibleContentRect(const IntRect& rect, int margin) { - IntRect viewport(m_viewport.fLeft - margin, m_viewport.fTop - margin, - m_viewport.width() + margin, m_viewport.height() + margin); + IntRect viewport(m_visibleContentRect.fLeft - margin, m_visibleContentRect.fTop - margin, + m_visibleContentRect.width() + margin, + m_visibleContentRect.height() + margin); viewport.intersect(rect); return viewport; } @@ -606,7 +613,8 @@ float ShaderProgram::zValue(const TransformationMatrix& drawMatrix, float w, flo { TransformationMatrix modifiedDrawMatrix = drawMatrix; modifiedDrawMatrix.scale3d(w, h, 1); - TransformationMatrix renderMatrix = m_visibleRectProjectionMatrix * modifiedDrawMatrix; + TransformationMatrix renderMatrix = + m_visibleContentRectProjectionMatrix * modifiedDrawMatrix; FloatPoint3D point(0.5, 0.5, 0.0); FloatPoint3D result = renderMatrix.mapPoint(point); return result.z(); diff --git a/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.h b/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.h index 8c9e301..4243e12 100644 --- a/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.h +++ b/Source/WebCore/platform/graphics/android/rendering/ShaderProgram.h @@ -115,8 +115,8 @@ public: void initGLResources(); void cleanupGLResources(); // Drawing - void setupDrawing(const IntRect& viewRect, const SkRect& visibleRect, - const IntRect& webViewRect, int titleBarHeight, + void setupDrawing(const IntRect& invScreenRect, const SkRect& visibleContentRect, + const IntRect& screenRect, int titleBarHeight, const IntRect& screenClip, float scale); float zValue(const TransformationMatrix& drawMatrix, float w, float h); @@ -130,20 +130,20 @@ public: void drawQuad(const DrawQuadData* data); void drawVideoLayerQuad(const TransformationMatrix& drawMatrix, float* textureMatrix, SkRect& geometry, int textureId); - FloatRect rectInScreenCoord(const TransformationMatrix& drawMatrix, + FloatRect rectInInvViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size); - FloatRect rectInInvScreenCoord(const TransformationMatrix& drawMatrix, + FloatRect rectInViewCoord(const TransformationMatrix& drawMatrix, const IntSize& size); - FloatRect rectInInvScreenCoord(const FloatRect& rect); - FloatRect rectInScreenCoord(const FloatRect& rect); - FloatRect convertScreenCoordToDocumentCoord(const FloatRect& rect); - FloatRect convertInvScreenCoordToScreenCoord(const FloatRect& rect); - FloatRect convertScreenCoordToInvScreenCoord(const FloatRect& rect); + FloatRect rectInViewCoord(const FloatRect& rect); + FloatRect rectInInvViewCoord(const FloatRect& rect); + FloatRect convertInvViewCoordToContentCoord(const FloatRect& rect); + FloatRect convertViewCoordToInvViewCoord(const FloatRect& rect); + FloatRect convertInvViewCoordToViewCoord(const FloatRect& rect); void clip(const FloatRect& rect); - IntRect clippedRectWithViewport(const IntRect& rect, int margin = 0); - FloatRect documentViewport() { return m_documentViewport; } + IntRect clippedRectWithVisibleContentRect(const IntRect& rect, int margin = 0); + FloatRect contentViewport() { return m_contentViewport; } float contrast() { return m_contrast; } void setContrast(float c) @@ -185,21 +185,21 @@ private: TransformationMatrix m_surfaceProjectionMatrix; TransformationMatrix m_clipProjectionMatrix; - TransformationMatrix m_visibleRectProjectionMatrix; + TransformationMatrix m_visibleContentRectProjectionMatrix; GLuint m_textureBuffer[1]; - TransformationMatrix m_documentToScreenMatrix; - TransformationMatrix m_documentToInvScreenMatrix; - SkRect m_viewport; - IntRect m_viewRect; + TransformationMatrix m_contentToInvViewMatrix; + TransformationMatrix m_contentToViewMatrix; + SkRect m_visibleContentRect; + IntRect m_invScreenRect; FloatRect m_clipRect; - IntRect m_screenClip; + IntRect m_invViewClip; int m_titleBarHeight; // This is the layout position in screen coordinate and didn't contain the // animation offset. - IntRect m_webViewRect; + IntRect m_screenRect; - FloatRect m_documentViewport; + FloatRect m_contentViewport; float m_contrast; diff --git a/Source/WebCore/platform/graphics/android/rendering/Surface.cpp b/Source/WebCore/platform/graphics/android/rendering/Surface.cpp index 652c165..16cad27 100644 --- a/Source/WebCore/platform/graphics/android/rendering/Surface.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/Surface.cpp @@ -45,7 +45,7 @@ #include <wtf/text/CString.h> // Surfaces with an area larger than 2048*2048 should never be unclipped -#define MAX_UNCLIPPED_AREA 4194304 +#define MAX_FULL_CONTENT_AREA 4194304 namespace WebCore { @@ -131,48 +131,48 @@ void Surface::addLayer(LayerAndroid* layer, const TransformationMatrix& transfor m_hasText |= layer->hasText(); // calculate area size for comparison later - IntRect rect = layer->unclippedArea(); + IntRect rect = layer->fullContentArea(); SkPoint pos = layer->getPosition(); rect.setLocation(IntPoint(pos.fX, pos.fY)); if (layer->needsTexture()) { - if (m_unclippedArea.isEmpty()) { + if (m_fullContentArea.isEmpty()) { m_drawTransform = transform; m_drawTransform.translate3d(-pos.fX, -pos.fY, 0); - m_unclippedArea = rect; + m_fullContentArea = rect; } else - m_unclippedArea.unite(rect); + m_fullContentArea.unite(rect); ALOGV("Surf %p adding LA %p, size %d, %d %dx%d, now Surf size %d,%d %dx%d", this, layer, rect.x(), rect.y(), rect.width(), rect.height(), - m_unclippedArea.x(), m_unclippedArea.y(), - m_unclippedArea.width(), m_unclippedArea.height()); + m_fullContentArea.x(), m_fullContentArea.y(), + m_fullContentArea.width(), m_fullContentArea.height()); } if (isBase()) m_background = static_cast<BaseLayerAndroid*>(layer)->getBackgroundColor(); } -IntRect Surface::visibleArea() +IntRect Surface::visibleContentArea() { if (singleLayer()) - return getFirstLayer()->visibleArea(); + return getFirstLayer()->visibleContentArea(); - IntRect rect = m_unclippedArea; + IntRect rect = m_fullContentArea; - // clip with the viewport in documents coordinate - IntRect documentViewport(TilesManager::instance()->shader()->documentViewport()); - rect.intersect(documentViewport); + // clip with the viewport in content coordinate + IntRect contentViewport(TilesManager::instance()->shader()->contentViewport()); + rect.intersect(contentViewport); // TODO: handle recursive layer clip return rect; } -IntRect Surface::unclippedArea() +IntRect Surface::fullContentArea() { if (singleLayer()) - return getFirstLayer()->unclippedArea(); - return m_unclippedArea; + return getFirstLayer()->fullContentArea(); + return m_fullContentArea; } bool Surface::useAggressiveRendering() @@ -203,7 +203,7 @@ void Surface::prepareGL(bool layerTilesDisabled, bool updateWithBlit) } else { bool allowZoom = hasText(); // only allow for scale > 1 if painting vectors IntRect prepareArea = computePrepareArea(); - IntRect fullArea = unclippedArea(); + IntRect fullArea = fullContentArea(); ALOGV("prepareGL on Surf %p with SurfBack %p, %d layers, first layer %s (%d) " "prepareArea(%d, %d - %d x %d) fullArea(%d, %d - %d x %d)", @@ -239,7 +239,7 @@ bool Surface::drawGL(bool layerTilesDisabled) if (!isBaseLayer) { // TODO: why are clipping regions wrong for base layer? FloatRect drawClip = getFirstLayer()->drawClip(); - FloatRect clippingRect = TilesManager::instance()->shader()->rectInScreenCoord(drawClip); + FloatRect clippingRect = TilesManager::instance()->shader()->rectInInvViewCoord(drawClip); TilesManager::instance()->shader()->clip(clippingRect); } @@ -248,7 +248,7 @@ bool Surface::drawGL(bool layerTilesDisabled) ALOGV("drawGL on Surf %p with SurfBack %p, first layer %s (%d)", this, m_surfaceBacking, getFirstLayer()->subclassName().ascii().data(), getFirstLayer()->uniqueId()); - IntRect drawArea = visibleArea(); + IntRect drawArea = visibleContentArea(); m_surfaceBacking->drawGL(drawArea, opacity(), drawTransform(), useAggressiveRendering(), background()); } @@ -312,13 +312,13 @@ IntRect Surface::computePrepareArea() && !isBase() && getFirstLayer()->state()->layersRenderingMode() == GLWebViewState::kAllTextures) { - area = unclippedArea(); + area = fullContentArea(); double total = ((double) area.width()) * ((double) area.height()); - if (total > MAX_UNCLIPPED_AREA) - area = visibleArea(); + if (total > MAX_FULL_CONTENT_AREA) + area = visibleContentArea(); } else - area = visibleArea(); + area = visibleContentArea(); return area; } diff --git a/Source/WebCore/platform/graphics/android/rendering/Surface.h b/Source/WebCore/platform/graphics/android/rendering/Surface.h index dc46fcf..50839ee 100644 --- a/Source/WebCore/platform/graphics/android/rendering/Surface.h +++ b/Source/WebCore/platform/graphics/android/rendering/Surface.h @@ -71,13 +71,13 @@ public: private: IntRect computePrepareArea(); - IntRect visibleArea(); - IntRect unclippedArea(); + IntRect visibleContentArea(); + IntRect fullContentArea(); bool singleLayer() { return m_layers.size() == 1; } bool useAggressiveRendering(); const TransformationMatrix* drawTransform(); - IntRect m_unclippedArea; + IntRect m_fullContentArea; TransformationMatrix m_drawTransform; SurfaceBacking* m_surfaceBacking; diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.cpp b/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.cpp index 957aa63..af96560 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.cpp @@ -56,7 +56,7 @@ SurfaceBacking::~SurfaceBacking() } void SurfaceBacking::prepareGL(GLWebViewState* state, bool allowZoom, - const IntRect& prepareArea, const IntRect& unclippedArea, + const IntRect& prepareArea, const IntRect& fullContentArea, TilePainter* painter, bool aggressiveRendering, bool updateWithBlit) { @@ -89,7 +89,7 @@ void SurfaceBacking::prepareGL(GLWebViewState* state, bool allowZoom, if (m_zooming && (m_zoomUpdateTime < WTF::currentTime())) { // prepare the visible portions of the back tile grid at the futureScale m_backTileGrid->prepareGL(state, m_futureScale, - prepareArea, unclippedArea, painter, + prepareArea, fullContentArea, painter, TileGrid::StandardRegion, false); if (m_backTileGrid->isReady()) { @@ -114,29 +114,29 @@ void SurfaceBacking::prepareGL(GLWebViewState* state, bool allowZoom, // if the front grid hasn't already prepared, or needs to prepare // expanded bounds do so now m_frontTileGrid->prepareGL(state, m_scale, - prepareArea, unclippedArea, painter, + prepareArea, fullContentArea, painter, prepareRegionFlags, false, updateWithBlit); } if (aggressiveRendering) { // prepare low res content float lowResPrefetchScale = m_scale * LOW_RES_PREFETCH_SCALE_MODIFIER; m_lowResTileGrid->prepareGL(state, lowResPrefetchScale, - prepareArea, unclippedArea, painter, + prepareArea, fullContentArea, painter, TileGrid::StandardRegion | TileGrid::ExpandedRegion, true); m_lowResTileGrid->swapTiles(); } } } -void SurfaceBacking::drawGL(const IntRect& visibleArea, float opacity, +void SurfaceBacking::drawGL(const IntRect& visibleContentArea, float opacity, const TransformationMatrix* transform, bool aggressiveRendering, const Color* background) { // draw low res prefetch page if zooming or front texture missing content if (aggressiveRendering && isMissingContent()) - m_lowResTileGrid->drawGL(visibleArea, opacity, transform); + m_lowResTileGrid->drawGL(visibleContentArea, opacity, transform); - m_frontTileGrid->drawGL(visibleArea, opacity, transform, background); + m_frontTileGrid->drawGL(visibleContentArea, opacity, transform, background); } void SurfaceBacking::markAsDirty(const SkRegion& dirtyArea) @@ -159,14 +159,14 @@ void SurfaceBacking::computeTexturesAmount(TexturesResult* result, LayerAndroid* if (!layer) return; - IntRect unclippedArea = layer->unclippedArea(); - IntRect clippedVisibleArea = layer->visibleArea(); + IntRect fullContentArea = layer->fullContentArea(); + IntRect clippedVisibleArea = layer->visibleContentArea(); // get two numbers here: // - textures needed for a clipped area // - textures needed for an un-clipped area TileGrid* tileGrid = m_zooming ? m_backTileGrid : m_frontTileGrid; - int nbTexturesUnclipped = tileGrid->nbTextures(unclippedArea, m_scale); + int nbTexturesUnclipped = tileGrid->nbTextures(fullContentArea, m_scale); int nbTexturesClipped = tileGrid->nbTextures(clippedVisibleArea, m_scale); // Set kFixedLayers level diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.h b/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.h index 08cfc7c..7d3e93c 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.h +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceBacking.h @@ -41,11 +41,11 @@ public: SurfaceBacking(bool isBaseSurface); ~SurfaceBacking(); void prepareGL(GLWebViewState* state, bool allowZoom, - const IntRect& prepareArea, const IntRect& unclippedArea, + const IntRect& prepareArea, const IntRect& fullContentArea, TilePainter* painter, bool aggressiveRendering, bool updateWithBlit); void swapTiles(); - void drawGL(const IntRect& visibleArea, float opacity, + void drawGL(const IntRect& visibleContentArea, float opacity, const TransformationMatrix* transform, bool aggressiveRendering, const Color* background); void markAsDirty(const SkRegion& dirtyArea); diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.cpp b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.cpp index cf59044..0bdbf38 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.cpp @@ -83,9 +83,9 @@ SurfaceCollection::~SurfaceCollection() #endif } -void SurfaceCollection::prepareGL(const SkRect& visibleRect) +void SurfaceCollection::prepareGL(const SkRect& visibleContentRect) { - updateLayerPositions(visibleRect); + updateLayerPositions(visibleContentRect); bool layerTilesDisabled = m_compositedRoot->state()->layersRenderingMode() > GLWebViewState::kClippedTextures; bool updateWithBlit = true; @@ -109,14 +109,14 @@ static inline bool compareSurfaceZ(const Surface* a, const Surface* b) return (la->zValue() > lb->zValue()) && (la->getParent() == lb->getParent()); } -bool SurfaceCollection::drawGL(const SkRect& visibleRect) +bool SurfaceCollection::drawGL(const SkRect& visibleContentRect) { #ifdef DEBUG_COUNT ClassTracker::instance()->show(); #endif bool needsRedraw = false; - updateLayerPositions(visibleRect); + updateLayerPositions(visibleContentRect); bool layerTilesDisabled = m_compositedRoot->state()->layersRenderingMode() > GLWebViewState::kClippedTextures; @@ -231,10 +231,10 @@ void SurfaceCollection::updateScrollableLayer(int layerId, int x, int y) static_cast<ScrollableLayerAndroid*>(layer)->scrollTo(x, y); } -void SurfaceCollection::updateLayerPositions(const SkRect& visibleRect) +void SurfaceCollection::updateLayerPositions(const SkRect& visibleContentRect) { TransformationMatrix ident; - m_compositedRoot->updateLayerPositions(visibleRect); + m_compositedRoot->updateLayerPositions(visibleContentRect); FloatRect clip(0, 0, 1e10, 1e10); m_compositedRoot->updateGLPositionsAndScale( ident, clip, 1, m_compositedRoot->state()->scale()); diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.h b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.h index 7dfe140..5cfd943 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.h +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollection.h @@ -48,8 +48,8 @@ public: virtual ~SurfaceCollection(); // Tiled painting methods (executed on groups) - void prepareGL(const SkRect& visibleRect); - bool drawGL(const SkRect& visibleRect); + void prepareGL(const SkRect& visibleContentRect); + bool drawGL(const SkRect& visibleContentRect); Color getBackgroundColor(); void swapTiles(); bool isReady(); @@ -67,7 +67,7 @@ public: void updateScrollableLayer(int layerId, int x, int y); private: - void updateLayerPositions(const SkRect& visibleRect); + void updateLayerPositions(const SkRect& visibleContentRect); LayerAndroid* m_compositedRoot; WTF::Vector<Surface*> m_surfaces; }; diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.cpp b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.cpp index 52a8e44..b26be03 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.cpp @@ -154,7 +154,7 @@ void SurfaceCollectionManager::updateScrollableLayer(int layerId, int x, int y) } int SurfaceCollectionManager::drawGL(double currentTime, IntRect& viewRect, - SkRect& visibleRect, float scale, + SkRect& visibleContentRect, float scale, bool enterFastSwapMode, bool* collectionsSwappedPtr, bool* newCollectionHasAnimPtr, TexturesResult* texturesResultPtr, bool shouldDraw) @@ -171,7 +171,7 @@ int SurfaceCollectionManager::drawGL(double currentTime, IntRect& viewRect, m_paintingCollection->evaluateAnimations(currentTime); - m_paintingCollection->prepareGL(visibleRect); + m_paintingCollection->prepareGL(visibleContentRect); m_paintingCollection->computeTexturesAmount(texturesResultPtr); if (!TilesManager::instance()->useDoubleBuffering() || m_paintingCollection->isReady()) { @@ -186,7 +186,7 @@ int SurfaceCollectionManager::drawGL(double currentTime, IntRect& viewRect, } } else if (m_drawingCollection) { ALOGV("preparing drawing collection %p", m_drawingCollection); - m_drawingCollection->prepareGL(visibleRect); + m_drawingCollection->prepareGL(visibleContentRect); m_drawingCollection->computeTexturesAmount(texturesResultPtr); } @@ -254,7 +254,7 @@ int SurfaceCollectionManager::drawGL(double currentTime, IntRect& viewRect, GLUtils::clearBackgroundIfOpaque(&background); } - if (m_drawingCollection && m_drawingCollection->drawGL(visibleRect)) + if (m_drawingCollection && m_drawingCollection->drawGL(visibleContentRect)) returnFlags |= uirenderer::DrawGlInfo::kStatusDraw; ALOGV("returnFlags %d, m_paintingCollection %d ", returnFlags, m_paintingCollection); diff --git a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.h b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.h index 125bf02..be4fbca 100644 --- a/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.h +++ b/Source/WebCore/platform/graphics/android/rendering/SurfaceCollectionManager.h @@ -50,7 +50,7 @@ public: void updateScrollableLayer(int layerId, int x, int y); int drawGL(double currentTime, IntRect& viewRect, - SkRect& visibleRect, float scale, + SkRect& visibleContentRect, float scale, bool enterFastSwapMode, bool* collectionsSwappedPtr, bool* newCollectionHasAnimPtr, TexturesResult* texturesResultPtr, bool shouldDraw); diff --git a/Source/WebCore/platform/graphics/android/rendering/TileGrid.cpp b/Source/WebCore/platform/graphics/android/rendering/TileGrid.cpp index bee42ae..7680fc9 100644 --- a/Source/WebCore/platform/graphics/android/rendering/TileGrid.cpp +++ b/Source/WebCore/platform/graphics/android/rendering/TileGrid.cpp @@ -135,7 +135,7 @@ IntRect TileGrid::computeTilesArea(const IntRect& contentArea, float scale) } void TileGrid::prepareGL(GLWebViewState* state, float scale, - const IntRect& prepareArea, const IntRect& unclippedArea, + const IntRect& prepareArea, const IntRect& fullContentArea, TilePainter* painter, int regionFlags, bool isLowResPrefetch, bool updateWithBlit) { @@ -193,7 +193,7 @@ void TileGrid::prepareGL(GLWebViewState* state, float scale, } if (regionFlags & ExpandedRegion) { - IntRect fullArea = computeTilesArea(unclippedArea, scale); + IntRect fullArea = computeTilesArea(fullContentArea, scale); IntRect expandedArea = m_area; // on systems reporting highEndGfx=true and useMinimalMemory not set, use expanded bounds @@ -285,11 +285,11 @@ int TileGrid::nbTextures(IntRect& area, float scale) return numberTextures; } -void TileGrid::drawGL(const IntRect& visibleArea, float opacity, +void TileGrid::drawGL(const IntRect& visibleContentArea, float opacity, const TransformationMatrix* transform, const Color* background) { - m_area = computeTilesArea(visibleArea, m_scale); + m_area = computeTilesArea(visibleContentArea, m_scale); if (m_area.width() == 0 || m_area.height() == 0) return; @@ -311,10 +311,10 @@ void TileGrid::drawGL(const IntRect& visibleArea, float opacity, bool usePointSampling = TilesManager::instance()->shader()->usePointSampling(m_scale, transform); - float minTileX = visibleArea.x() / tileWidth; - float minTileY = visibleArea.y() / tileWidth; - float maxTileWidth = visibleArea.maxX() / tileWidth; - float maxTileHeight = visibleArea.maxY() / tileWidth; + float minTileX = visibleContentArea.x() / tileWidth; + float minTileY = visibleContentArea.y() / tileWidth; + float maxTileWidth = visibleContentArea.maxX() / tileWidth; + float maxTileHeight = visibleContentArea.maxY() / tileWidth; ALOGV("minTileX, minTileY, maxTileWidth, maxTileHeight %f, %f, %f %f", minTileX, minTileY, maxTileWidth, maxTileHeight); for (unsigned int i = 0; i < m_tiles.size(); i++) { diff --git a/Source/WebCore/platform/graphics/android/rendering/TileGrid.h b/Source/WebCore/platform/graphics/android/rendering/TileGrid.h index e412979..b480419 100644 --- a/Source/WebCore/platform/graphics/android/rendering/TileGrid.h +++ b/Source/WebCore/platform/graphics/android/rendering/TileGrid.h @@ -49,11 +49,11 @@ public: static IntRect computeTilesArea(const IntRect& contentArea, float scale); void prepareGL(GLWebViewState* state, float scale, - const IntRect& prepareArea, const IntRect& unclippedArea, + const IntRect& prepareArea, const IntRect& fullContentArea, TilePainter* painter, int regionFlags = StandardRegion, bool isLowResPrefetch = false, bool updateWithBlit = false); void swapTiles(); - void drawGL(const IntRect& visibleArea, float opacity, + void drawGL(const IntRect& visibleContentArea, float opacity, const TransformationMatrix* transform, const Color* background = 0); void markAsDirty(const SkRegion& dirtyArea); |