Commit 22f4150e authored by Alberto Garcia's avatar Alberto Garcia
Browse files

Imported Upstream version 2.10.9

parent d320e6d4
This source diff could not be displayed because it is too large. You can view the blob instead.
......@@ -14,7 +14,7 @@
<div class="titlepage">
<div>
<div><table class="navigation" id="top" width="100%" cellpadding="2" cellspacing="0"><tr><th valign="middle"><p class="title">WebKit2GTK+ Reference Manual</p></th></tr></table></div>
<div><p class="releaseinfo">for WebKit2GTK+ 2.10.8</p></div>
<div><p class="releaseinfo">for WebKit2GTK+ 2.10.9</p></div>
</div>
<hr>
</div>
......
......@@ -177,7 +177,7 @@ against at application run time.</p>
<hr>
<div class="refsect2">
<a name="WEBKIT-MICRO-VERSION:CAPS"></a><h3>WEBKIT_MICRO_VERSION</h3>
<pre class="programlisting">#define WEBKIT_MICRO_VERSION (8)
<pre class="programlisting">#define WEBKIT_MICRO_VERSION (9)
</pre>
<p>Like <a class="link" href="webkit2gtk-4.0-WebKitVersion.html#webkit-get-micro-version" title="webkit_get_micro_version ()"><code class="function">webkit_get_micro_version()</code></a>, but from the headers used at
application compile time, rather than from the library linked
......
......@@ -14,7 +14,7 @@
<div class="titlepage">
<div>
<div><table class="navigation" id="top" width="100%" cellpadding="2" cellspacing="0"><tr><th valign="middle"><p class="title">WebKitDOMGTK+ Reference Manual</p></th></tr></table></div>
<div><p class="releaseinfo">for WebKitDOMGTK+ 2.10.8</p></div>
<div><p class="releaseinfo">for WebKitDOMGTK+ 2.10.9</p></div>
</div>
<hr>
</div>
......
=================
WebKitGTK+ 2.10.9
=================
What's new in WebKitGTK+ 2.10.9?
- Revert the patch to limit the number of tiles according to the visible area introduced in 2.10.8,
because it caused rendering issues in several popular websites.
- Fix the build with musl libc library.
- Fix the build with clang-3.8.
=================
WebKitGTK+ 2.10.8
=================
......
......@@ -610,7 +610,7 @@ bool Option::operator==(const Option& other) const
case Options::Type::unsignedType:
return m_entry.unsignedVal == other.m_entry.unsignedVal;
case Options::Type::doubleType:
return (m_entry.doubleVal == other.m_entry.doubleVal) || (isnan(m_entry.doubleVal) && isnan(other.m_entry.doubleVal));
return (m_entry.doubleVal == other.m_entry.doubleVal) || (std::isnan(m_entry.doubleVal) && std::isnan(other.m_entry.doubleVal));
case Options::Type::int32Type:
return m_entry.int32Val == other.m_entry.int32Val;
case Options::Type::optionRangeType:
......
......@@ -68,7 +68,7 @@
#include <unistd.h>
#endif
#if OS(DARWIN) || (OS(LINUX) && !defined(__UCLIBC__))
#if OS(DARWIN) || (OS(LINUX) && defined(__GLIBC__) && !defined(__UCLIBC__))
#include <cxxabi.h>
#include <dlfcn.h>
#include <execinfo.h>
......@@ -225,7 +225,7 @@ void WTFReportArgumentAssertionFailure(const char* file, int line, const char* f
void WTFGetBacktrace(void** stack, int* size)
{
#if OS(DARWIN) || (OS(LINUX) && !defined(__UCLIBC__))
#if OS(DARWIN) || (OS(LINUX) && defined(__GLIBC__) && !defined(__UCLIBC__))
*size = backtrace(stack, *size);
#elif OS(WINDOWS)
// The CaptureStackBackTrace function is available in XP, but it is not defined
......
......@@ -40,7 +40,7 @@
// are used from wx headers. On GTK+ for Mac many GTK+ files include <libintl.h>
// or <glib/gi18n-lib.h>, which in turn include <xlocale/_ctype.h> which uses
// isacii().
#if !(OS(DARWIN) && PLATFORM(GTK)) && !PLATFORM(EFL) && !defined(_LIBCPP_VERSION)
#if !(OS(DARWIN) && PLATFORM(GTK)) && !PLATFORM(EFL) && !defined(_LIBCPP_VERSION) && defined(__GLIBC__)
#include <ctype.h>
......
......@@ -48,8 +48,6 @@ GraphicsLayerTextureMapper::GraphicsLayerTextureMapper(Type layerType, GraphicsL
, m_contentsLayer(0)
, m_animationStartTime(0)
, m_isScrollable(false)
, m_isNonCompositingLayer(false)
, m_isVisibleRectDirty(true)
{
}
......@@ -169,7 +167,6 @@ void GraphicsLayerTextureMapper::setPosition(const FloatPoint& value)
return;
GraphicsLayer::setPosition(value);
notifyChange(PositionChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setAnchorPoint(const FloatPoint3D& value)
......@@ -178,7 +175,6 @@ void GraphicsLayerTextureMapper::setAnchorPoint(const FloatPoint3D& value)
return;
GraphicsLayer::setAnchorPoint(value);
notifyChange(AnchorPointChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setSize(const FloatSize& value)
......@@ -190,7 +186,6 @@ void GraphicsLayerTextureMapper::setSize(const FloatSize& value)
if (maskLayer())
maskLayer()->setSize(value);
notifyChange(SizeChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setTransform(const TransformationMatrix& value)
......@@ -200,7 +195,6 @@ void GraphicsLayerTextureMapper::setTransform(const TransformationMatrix& value)
GraphicsLayer::setTransform(value);
notifyChange(TransformChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setChildrenTransform(const TransformationMatrix& value)
......@@ -209,7 +203,6 @@ void GraphicsLayerTextureMapper::setChildrenTransform(const TransformationMatrix
return;
GraphicsLayer::setChildrenTransform(value);
notifyChange(ChildrenTransformChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setPreserves3D(bool value)
......@@ -218,7 +211,6 @@ void GraphicsLayerTextureMapper::setPreserves3D(bool value)
return;
GraphicsLayer::setPreserves3D(value);
notifyChange(Preserves3DChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setMasksToBounds(bool value)
......@@ -227,7 +219,6 @@ void GraphicsLayerTextureMapper::setMasksToBounds(bool value)
return;
GraphicsLayer::setMasksToBounds(value);
notifyChange(MasksToBoundsChange);
markVisibleRectAsDirty();
}
void GraphicsLayerTextureMapper::setDrawsContent(bool value)
......@@ -310,7 +301,6 @@ void GraphicsLayerTextureMapper::setContentsToImage(Image* image)
m_compositedImage = TextureMapperTiledBackingStore::create();
m_compositedImage->setContentsToImage(image);
m_compositedImage->updateContentsScale(pageScaleFactor() * deviceScaleFactor());
m_compositedImage->updateContentsSize(image->size());
} else {
m_compositedNativeImagePtr = nullptr;
m_compositedImage = nullptr;
......@@ -379,8 +369,6 @@ void GraphicsLayerTextureMapper::flushCompositingStateForThisLayerOnly(bool)
prepareBackingStoreIfNeeded();
commitLayerChanges();
m_layer.syncAnimations();
if (!m_isNonCompositingLayer)
computeTransformedVisibleRect();
}
void GraphicsLayerTextureMapper::prepareBackingStoreIfNeeded()
......@@ -524,22 +512,22 @@ void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect, bo
child->flushCompositingState(rect, viewportIsStable);
}
void GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers(const FloatRect& visibleContentRect)
void GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers()
{
if (!m_layer.textureMapper())
return;
updateBackingStoreIfNeeded(visibleContentRect);
updateBackingStoreIfNeeded();
if (maskLayer())
downcast<GraphicsLayerTextureMapper>(*maskLayer()).updateBackingStoreIfNeeded(visibleContentRect);
downcast<GraphicsLayerTextureMapper>(*maskLayer()).updateBackingStoreIfNeeded();
if (replicaLayer())
downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded(visibleContentRect);
downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded();
for (auto* child : children())
downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers(visibleContentRect);
downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers();
}
void GraphicsLayerTextureMapper::updateBackingStoreIfNeeded(const FloatRect& visibleContentRect)
void GraphicsLayerTextureMapper::updateBackingStoreIfNeeded()
{
TextureMapper* textureMapper = m_layer.textureMapper();
if (!textureMapper)
......@@ -559,10 +547,9 @@ void GraphicsLayerTextureMapper::updateBackingStoreIfNeeded(const FloatRect& vis
TextureMapperTiledBackingStore* backingStore = static_cast<TextureMapperTiledBackingStore*>(m_backingStore.get());
backingStore->updateContentsScale(pageScaleFactor() * deviceScaleFactor());
backingStore->updateContentsSize(m_size);
dirtyRect.scale(pageScaleFactor() * deviceScaleFactor());
backingStore->updateContents(textureMapper, this, transformedVisibleRect(visibleContentRect), dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
backingStore->updateContents(textureMapper, this, m_size, dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
m_needsDisplay = false;
m_needsDisplayRect = IntRect();
......@@ -639,81 +626,5 @@ void GraphicsLayerTextureMapper::setRepaintCount(int repaintCount)
notifyChange(RepaintCountChange);
}
void GraphicsLayerTextureMapper::markVisibleRectAsDirty()
{
m_isVisibleRectDirty = true;
if (maskLayer())
downcast<GraphicsLayerTextureMapper>(*maskLayer()).markVisibleRectAsDirty();
if (replicaLayer())
downcast<GraphicsLayerTextureMapper>(*replicaLayer()).markVisibleRectAsDirty();
for (auto* child : children())
downcast<GraphicsLayerTextureMapper>(*child).markVisibleRectAsDirty();
}
bool GraphicsLayerTextureMapper::selfOrAncestorHasActiveTransformAnimation() const
{
if (m_animations.hasActiveAnimationsOfType(AnimatedPropertyTransform))
return true;
if (!parent())
return false;
return downcast<GraphicsLayerTextureMapper>(*parent()).selfOrAncestorHasActiveTransformAnimation();
}
void GraphicsLayerTextureMapper::computeTransformedVisibleRect()
{
if (!m_isVisibleRectDirty && !selfOrAncestorHasActiveTransformAnimation())
return;
m_isVisibleRectDirty = false;
TransformationMatrix currentTransform = transform();
if (selfOrAncestorHasActiveTransformAnimation())
client().getCurrentTransform(this, currentTransform);
m_layerTransform.setLocalTransform(currentTransform);
m_layerTransform.setAnchorPoint(m_anchorPoint);
m_layerTransform.setPosition(m_position);
m_layerTransform.setSize(m_size);
m_layerTransform.setFlattening(!preserves3D());
m_layerTransform.setChildrenTransform(childrenTransform());
m_layerTransform.combineTransforms(parent() ? downcast<GraphicsLayerTextureMapper>(*parent()).m_layerTransform.combinedForChildren() : TransformationMatrix());
m_cachedInverseTransform = m_layerTransform.combined().isInvertible() ? m_layerTransform.combined().inverse() : TransformationMatrix();
}
static void clampToContentsRectIfRectIsInfinite(FloatRect& rect, const FloatSize& contentsSize)
{
if (rect.width() >= LayoutUnit::nearlyMax() || rect.width() <= LayoutUnit::nearlyMin()) {
rect.setX(0);
rect.setWidth(contentsSize.width());
}
if (rect.height() >= LayoutUnit::nearlyMax() || rect.height() <= LayoutUnit::nearlyMin()) {
rect.setY(0);
rect.setHeight(contentsSize.height());
}
}
FloatRect GraphicsLayerTextureMapper::transformedVisibleRect(const FloatRect& visibleContentRect)
{
if (m_isNonCompositingLayer)
return FloatRect(FloatPoint::zero(), m_size);
// Non-invertible layers are not visible.
if (!m_layerTransform.combined().isInvertible())
return IntRect();
// Return a projection of the visible rect (surface coordinates) onto the layer's plane (layer coordinates).
// The resulting quad might be squewed and the visible rect is the bounding box of this quad,
// so it might spread further than the real visible area (and then even more amplified by the cover rect multiplier).
ASSERT(m_cachedInverseTransform == m_layerTransform.combined().inverse().valueOr(TransformationMatrix()));
FloatRect rect = m_cachedInverseTransform.clampedBoundsOfProjectedQuad(FloatQuad(visibleContentRect));
clampToContentsRectIfRectIsInfinite(rect, size());
return rect;
}
}
#endif
......@@ -86,7 +86,7 @@ public:
virtual void flushCompositingState(const FloatRect&, bool) override;
virtual void flushCompositingStateForThisLayerOnly(bool) override;
void updateBackingStoreIncludingSubLayers(const FloatRect&);
void updateBackingStoreIncludingSubLayers();
TextureMapperLayer& layer() { return m_layer; }
......@@ -102,7 +102,6 @@ public:
void setRepaintCount(int);
void setAnimations(const TextureMapperAnimations&);
void setAsNonCompositingLayer() { m_isNonCompositingLayer = true; }
private:
// GraphicsLayer
......@@ -114,15 +113,10 @@ private:
void commitLayerChanges();
void updateDebugBorderAndRepaintCount();
void updateBackingStoreIfNeeded(const FloatRect&);
void updateBackingStoreIfNeeded();
void prepareBackingStoreIfNeeded();
bool shouldHaveBackingStore() const;
bool selfOrAncestorHasActiveTransformAnimation() const;
void computeTransformedVisibleRect();
void markVisibleRectAsDirty();
FloatRect transformedVisibleRect(const FloatRect&);
// This set of flags help us defer which properties of the layer have been
// modified by the compositor, so we can know what to look for in the next flush.
enum ChangeMask {
......@@ -188,11 +182,6 @@ private:
IntSize m_committedScrollOffset;
bool m_isScrollable;
bool m_isNonCompositingLayer;
bool m_isVisibleRectDirty;
GraphicsLayerTransform m_layerTransform;
TransformationMatrix m_cachedInverseTransform;
};
} // namespace WebCore
......
......@@ -34,29 +34,21 @@ void TextureMapperTiledBackingStore::updateContentsFromImageIfNeeded(TextureMapp
if (!m_image)
return;
updateContents(textureMapper, m_image.get(), m_image->rect(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);
updateContents(textureMapper, m_image.get(), m_image->size(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);
m_image = nullptr;
}
TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(const FloatRect& targetRect)
{
FloatRect scaledContentsRect(FloatPoint::zero(), m_contentsSize);
scaledContentsRect.scale(m_contentsScale);
return TransformationMatrix::rectToRect(scaledContentsRect, targetRect);
return TransformationMatrix::rectToRect(rect(), targetRect);
}
void TextureMapperTiledBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)
{
FloatRect scaledTargetRect(targetRect);
if (m_image)
scaledTargetRect.scale(m_contentsScale);
updateContentsFromImageIfNeeded(textureMapper);
TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(scaledTargetRect);
FloatRect scaledContentsRect(FloatPoint::zero(), m_contentsSize);
scaledContentsRect.scale(m_contentsScale);
TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
for (auto& tile : m_tiles)
tile.paint(textureMapper, adjustedTransform, opacity, calculateExposedTileEdges(scaledContentsRect, tile.rect()));
tile.paint(textureMapper, adjustedTransform, opacity, calculateExposedTileEdges(rect(), tile.rect()));
}
void TextureMapperTiledBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)
......@@ -82,37 +74,17 @@ void TextureMapperTiledBackingStore::updateContentsScale(float scale)
m_contentsScale = scale;
}
void TextureMapperTiledBackingStore::updateContentsSize(const FloatSize& size)
void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatSize& size, const IntSize& tileSize, bool hasAlpha)
{
if (m_contentsSize == size)
if (size == m_size && !m_isScaleDirty)
return;
m_isSizeDirty = true;
m_contentsSize = size;
}
void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatRect& visibleRect, const IntSize& tileSize, bool hasAlpha)
{
if (visibleRect == m_visibleRect && !m_isScaleDirty && !m_isSizeDirty)
return;
m_visibleRect = visibleRect;
m_size = size;
m_isScaleDirty = false;
m_isSizeDirty = false;
FloatRect scaledContentsRect(FloatRect(FloatPoint::zero(), m_contentsSize));
FloatRect scaledVisibleRect(m_visibleRect);
static const float coverRectMultiplier = 1.2;
FloatPoint delta(scaledVisibleRect.center());
delta.scale(1 - coverRectMultiplier, 1 - coverRectMultiplier);
scaledVisibleRect.scale(coverRectMultiplier);
scaledVisibleRect.moveBy(delta);
if (!m_image) {
scaledContentsRect.scale(m_contentsScale);
scaledVisibleRect.scale(m_contentsScale);
}
FloatSize scaledSize(m_size);
if (!m_image)
scaledSize.scale(m_contentsScale);
Vector<FloatRect> tileRectsToAdd;
Vector<int> tileIndicesToRemove;
......@@ -120,12 +92,11 @@ void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatRec
// This method recycles tiles. We check which tiles we need to add, which to remove, and use as many
// removable tiles as replacement for new tiles when possible.
for (float y = 0; y < scaledContentsRect.height(); y += tileSize.height()) {
for (float x = 0; x < scaledContentsRect.width(); x += tileSize.width()) {
for (float y = 0; y < scaledSize.height(); y += tileSize.height()) {
for (float x = 0; x < scaledSize.width(); x += tileSize.width()) {
FloatRect tileRect(x, y, tileSize.width(), tileSize.height());
tileRect.intersect(scaledContentsRect);
if (tileRect.intersects(scaledVisibleRect))
tileRectsToAdd.append(tileRect);
tileRect.intersect(rect());
tileRectsToAdd.append(tileRect);
}
}
......@@ -175,16 +146,16 @@ void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatRec
}
}
void TextureMapperTiledBackingStore::updateContents(TextureMapper* textureMapper, Image* image, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
void TextureMapperTiledBackingStore::updateContents(TextureMapper* textureMapper, Image* image, const FloatSize& totalSize, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
{
createOrDestroyTilesIfNeeded(visibleRect, textureMapper->maxTextureSize(), !image->currentFrameKnownToBeOpaque());
createOrDestroyTilesIfNeeded(totalSize, textureMapper->maxTextureSize(), !image->currentFrameKnownToBeOpaque());
for (auto& tile : m_tiles)
tile.updateContents(textureMapper, image, dirtyRect, updateContentsFlag);
}
void TextureMapperTiledBackingStore::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
void TextureMapperTiledBackingStore::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const FloatSize& totalSize, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
{
createOrDestroyTilesIfNeeded(visibleRect, textureMapper->maxTextureSize(), true);
createOrDestroyTilesIfNeeded(totalSize, textureMapper->maxTextureSize(), true);
for (auto& tile : m_tiles)
tile.updateContents(textureMapper, sourceLayer, dirtyRect, updateContentsFlag, m_contentsScale);
}
......
......@@ -43,29 +43,29 @@ public:
virtual void drawRepaintCounter(TextureMapper*, int repaintCount, const Color&, const FloatRect&, const TransformationMatrix&) override;
void updateContentsScale(float);
void updateContentsSize(const FloatSize&);
void updateContents(TextureMapper*, Image*, const FloatRect&, const IntRect&, BitmapTexture::UpdateContentsFlag);
void updateContents(TextureMapper*, GraphicsLayer*, const FloatRect&, const IntRect&, BitmapTexture::UpdateContentsFlag);
void updateContents(TextureMapper*, Image*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
void updateContents(TextureMapper*, GraphicsLayer*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
void setContentsToImage(Image* image) { m_image = image; }
private:
TextureMapperTiledBackingStore() { }
void createOrDestroyTilesIfNeeded(const FloatRect& visibleRect, const IntSize& tileSize, bool hasAlpha);
void createOrDestroyTilesIfNeeded(const FloatSize& backingStoreSize, const IntSize& tileSize, bool hasAlpha);
void updateContentsFromImageIfNeeded(TextureMapper*);
TransformationMatrix adjustedTransformForRect(const FloatRect&);
inline FloatRect rect() const
{
FloatRect rect(FloatPoint::zero(), m_size);
rect.scale(m_contentsScale);
return rect;
}
Vector<TextureMapperTile> m_tiles;
FloatSize m_contentsSize;
FloatRect m_visibleRect;
FloatRect m_scaledvisibleRect;
FloatSize m_size;
RefPtr<Image> m_image;
float m_contentsScale { 1 };
bool m_isScaleDirty { false };
bool m_isSizeDirty { false };
};
} // namespace WebCore
......
......@@ -201,8 +201,10 @@ void MemoryPressureHandler::respondToMemoryPressure(Critical critical, Synchrono
void MemoryPressureHandler::platformReleaseMemory(Critical)
{
#ifdef __GLIBC__
ReliefLogger log("Run malloc_trim");
malloc_trim(0);
#endif
}
void MemoryPressureHandler::ReliefLogger::platformLog()
......
......@@ -48,6 +48,8 @@ void WebPreferences::platformInitializeStore()
#else
if (getenv("WEBKIT_FORCE_COMPOSITING_MODE"))
setForceCompositingMode(true);
if (getenv("WEBKIT_DISABLE_COMPOSITING_MODE"))
setAcceleratedCompositingEnabled(false);
#endif
}
......
......@@ -107,7 +107,6 @@ void LayerTreeHostGtk::initialize()
// The non-composited contents are a child of the root layer.
m_nonCompositedContentLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
downcast<GraphicsLayerTextureMapper>(*m_nonCompositedContentLayer).setAsNonCompositingLayer();
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
m_nonCompositedContentLayer->setSize(m_webPage->size());
......@@ -292,8 +291,7 @@ bool LayerTreeHostGtk::flushPendingLayerChanges()
if (m_viewOverlayRootLayer)
m_viewOverlayRootLayer->flushCompositingState(FloatRect(FloatPoint(), m_rootLayer->size()), viewportIsStable);
FloatRect visibleRect(m_webPage->mainFrame()->view()->scrollPosition(), m_webPage->size());
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).updateBackingStoreIncludingSubLayers(visibleRect);
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).updateBackingStoreIncludingSubLayers();
return true;
}
......
=================
WebKitGTK+ 2.10.9
=================
What's new in WebKitGTK+ 2.10.9?
- Revert the patch to limit the number of tiles according to the visible area introduced in 2.10.8,
because it caused rendering issues in several popular websites.
- Fix the build with musl libc library.
- Fix the build with clang-3.8.
=================
WebKitGTK+ 2.10.8
=================
......
......@@ -2,7 +2,7 @@ include(GNUInstallDirs)
set(PROJECT_VERSION_MAJOR 2)
set(PROJECT_VERSION_MINOR 10)
set(PROJECT_VERSION_MICRO 8)
set(PROJECT_VERSION_MICRO 9)
set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_MICRO})
set(WEBKITGTK_API_VERSION 4.0)
......@@ -15,8 +15,8 @@ endif ()
# Libtool library version, not to be confused with API version.
# See http://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html
CALCULATE_LIBRARY_VERSIONS_FROM_LIBTOOL_TRIPLE(WEBKIT2 48 11 11)
CALCULATE_LIBRARY_VERSIONS_FROM_LIBTOOL_TRIPLE(JAVASCRIPTCORE 20 16 2)
CALCULATE_LIBRARY_VERSIONS_FROM_LIBTOOL_TRIPLE(WEBKIT2 48 12 11)
CALCULATE_LIBRARY_VERSIONS_FROM_LIBTOOL_TRIPLE(JAVASCRIPTCORE 20 17 2)
# These are shared variables, but we special case their definition so that we can use the
# CMAKE_INSTALL_* variables that are populated by the GNUInstallDirs macro.
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment