<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[176946] trunk/Source/WebKit2</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/176946">176946</a></dd>
<dt>Author</dt> <dd>yoon@igalia.com</dd>
<dt>Date</dt> <dd>2014-12-08 04:09:30 -0800 (Mon, 08 Dec 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>[CoordinatedGraphics] Move CoordinatedBackingStore and CoordinatedGraphicsScene to Shared
https://bugs.webkit.org/show_bug.cgi?id=139385
Reviewed by Martin Robinson.
For the Threaded Compositor, CoordinatedBackingStore and
CoordinatedGraphicsScene should be placed at the Shared instead of
UIProcess because it can be used in the WebProcess also.
No new tests because there is no behavior change.
* PlatformEfl.cmake:
* Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp.
* Shared/CoordinatedGraphics/CoordinatedBackingStore.h: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h.
* Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp.
* Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2ChangeLog">trunk/Source/WebKit2/ChangeLog</a></li>
<li><a href="#trunkSourceWebKit2PlatformEflcmake">trunk/Source/WebKit2/PlatformEfl.cmake</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedBackingStorecpp">trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp</a></li>
<li><a href="#trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedBackingStoreh">trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.h</a></li>
<li><a href="#trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedGraphicsScenecpp">trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp</a></li>
<li><a href="#trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedGraphicsSceneh">trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h</a></li>
</ul>
<h3>Removed Paths</h3>
<ul>
<li><a href="#trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStorecpp">trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp</a></li>
<li><a href="#trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStoreh">trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h</a></li>
<li><a href="#trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsScenecpp">trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp</a></li>
<li><a href="#trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsSceneh">trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebKit2ChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/ChangeLog (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/ChangeLog 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/ChangeLog 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -1,3 +1,22 @@
</span><ins>+2014-12-08 Gwang Yoon Hwang <yoon@igalia.com>
+
+ [CoordinatedGraphics] Move CoordinatedBackingStore and CoordinatedGraphicsScene to Shared
+ https://bugs.webkit.org/show_bug.cgi?id=139385
+
+ Reviewed by Martin Robinson.
+
+ For the Threaded Compositor, CoordinatedBackingStore and
+ CoordinatedGraphicsScene should be placed at the Shared instead of
+ UIProcess because it can be used in the WebProcess also.
+
+ No new tests because there is no behavior change.
+
+ * PlatformEfl.cmake:
+ * Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp.
+ * Shared/CoordinatedGraphics/CoordinatedBackingStore.h: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h.
+ * Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp.
+ * Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h: Renamed from Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h.
+
</ins><span class="cx"> 2014-12-08 Shivakumar JM <shiva.jm@samsung.com>
</span><span class="cx">
</span><span class="cx"> Fix build warning in WebKit2/UIProcess module.
</span></span></pre></div>
<a id="trunkSourceWebKit2PlatformEflcmake"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit2/PlatformEfl.cmake (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/PlatformEfl.cmake 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/PlatformEfl.cmake 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -23,7 +23,9 @@
</span><span class="cx">
</span><span class="cx"> Shared/API/c/efl/WKArrayEfl.cpp
</span><span class="cx">
</span><ins>+ Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp
</ins><span class="cx"> Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp
</span><ins>+ Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp
</ins><span class="cx"> Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp
</span><span class="cx">
</span><span class="cx"> Shared/Downloads/efl/DownloadSoupErrorsEfl.cpp
</span><span class="lines">@@ -113,9 +115,7 @@
</span><span class="cx"> UIProcess/API/efl/ewk_view.cpp
</span><span class="cx"> UIProcess/API/efl/ewk_window_features.cpp
</span><span class="cx">
</span><del>- UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp
</del><span class="cx"> UIProcess/CoordinatedGraphics/CoordinatedDrawingAreaProxy.cpp
</span><del>- UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp
</del><span class="cx"> UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp
</span><span class="cx"> UIProcess/CoordinatedGraphics/PageViewportController.cpp
</span><span class="cx"> UIProcess/CoordinatedGraphics/WebPageProxyCoordinatedGraphics.cpp
</span></span></pre></div>
<a id="trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedBackingStorecppfromrev176945trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStorecpp"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp (from rev 176945, trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp) (0 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp (rev 0)
+++ trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -0,0 +1,188 @@
</span><ins>+/*
+ Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "CoordinatedBackingStore.h"
+
+#if USE(COORDINATED_GRAPHICS)
+#include <WebCore/CoordinatedSurface.h>
+#include <WebCore/GraphicsLayer.h>
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperGL.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper)
+{
+ if (!m_surface)
+ return;
+
+ FloatRect tileRect(m_tileRect);
+ tileRect.scale(1. / m_scale);
+ bool shouldReset = false;
+ if (tileRect != rect()) {
+ setRect(tileRect);
+ shouldReset = true;
+ }
+ RefPtr<BitmapTexture> texture = this->texture();
+ if (!texture) {
+ texture = textureMapper->createTexture();
+ setTexture(texture.get());
+ shouldReset = true;
+ }
+
+ ASSERT(textureMapper->maxTextureSize().width() >= m_tileRect.size().width());
+ ASSERT(textureMapper->maxTextureSize().height() >= m_tileRect.size().height());
+ if (shouldReset)
+ texture->reset(m_tileRect.size(), m_surface->supportsAlpha());
+
+ m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);
+ m_surface.clear();
+}
+
+void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)
+{
+ m_sourceRect = sourceRect;
+ m_tileRect = tileRect;
+ m_surfaceOffset = offset;
+ m_surface = buffer;
+}
+
+void CoordinatedBackingStore::createTile(uint32_t id, float scale)
+{
+ m_tiles.add(id, CoordinatedBackingStoreTile(scale));
+ m_scale = scale;
+}
+
+void CoordinatedBackingStore::removeTile(uint32_t id)
+{
+ ASSERT(m_tiles.contains(id));
+ m_tilesToRemove.add(id);
+}
+
+void CoordinatedBackingStore::removeAllTiles()
+{
+ for (auto& key : m_tiles.keys())
+ m_tilesToRemove.add(key);
+}
+
+void CoordinatedBackingStore::updateTile(uint32_t id, const IntRect& sourceRect, const IntRect& tileRect, PassRefPtr<CoordinatedSurface> backBuffer, const IntPoint& offset)
+{
+ CoordinatedBackingStoreTileMap::iterator it = m_tiles.find(id);
+ ASSERT(it != m_tiles.end());
+ it->value.setBackBuffer(tileRect, sourceRect, backBuffer, offset);
+}
+
+PassRefPtr<BitmapTexture> CoordinatedBackingStore::texture() const
+{
+ for (auto& tile : m_tiles.values()) {
+ RefPtr<BitmapTexture> texture = tile.texture();
+ if (texture)
+ return texture;
+ }
+
+ return PassRefPtr<BitmapTexture>();
+}
+
+void CoordinatedBackingStore::setSize(const FloatSize& size)
+{
+ m_pendingSize = size;
+}
+
+void CoordinatedBackingStore::paintTilesToTextureMapper(Vector<TextureMapperTile*>& tiles, TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, const FloatRect& rect)
+{
+ for (auto& tile : tiles)
+ tile->paint(textureMapper, transform, opacity, calculateExposedTileEdges(rect, tile->rect()));
+}
+
+TransformationMatrix CoordinatedBackingStore::adjustedTransformForRect(const FloatRect& targetRect)
+{
+ return TransformationMatrix::rectToRect(rect(), targetRect);
+}
+
+void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)
+{
+ if (m_tiles.isEmpty())
+ return;
+ ASSERT(!m_size.isZero());
+
+ Vector<TextureMapperTile*> tilesToPaint;
+ Vector<TextureMapperTile*> previousTilesToPaint;
+
+ // We have to do this every time we paint, in case the opacity has changed.
+ FloatRect coveredRect;
+ for (auto& tile : m_tiles.values()) {
+ if (!tile.texture())
+ continue;
+
+ if (tile.scale() == m_scale) {
+ tilesToPaint.append(&tile);
+ coveredRect.unite(tile.rect());
+ continue;
+ }
+
+ // Only show the previous tile if the opacity is high, otherwise effect looks like a bug.
+ // We show the previous-scale tile anyway if it doesn't intersect with any current-scale tile.
+ if (opacity < 0.95 && coveredRect.intersects(tile.rect()))
+ continue;
+
+ previousTilesToPaint.append(&tile);
+ }
+
+ // targetRect is on the contents coordinate system, so we must compare two rects on the contents coordinate system.
+ // See TiledBackingStore.
+ TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
+
+ paintTilesToTextureMapper(previousTilesToPaint, textureMapper, adjustedTransform, opacity, rect());
+ paintTilesToTextureMapper(tilesToPaint, textureMapper, adjustedTransform, opacity, rect());
+}
+
+void CoordinatedBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)
+{
+ TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
+ for (auto& tile : m_tiles.values())
+ textureMapper->drawBorder(borderColor, borderWidth, tile.rect(), adjustedTransform);
+}
+
+void CoordinatedBackingStore::drawRepaintCounter(TextureMapper* textureMapper, int repaintCount, const Color& borderColor, const FloatRect& targetRect, const TransformationMatrix& transform)
+{
+ TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
+ for (auto& tile : m_tiles.values())
+ textureMapper->drawNumber(repaintCount, borderColor, tile.rect().location(), adjustedTransform);
+}
+
+void CoordinatedBackingStore::commitTileOperations(TextureMapper* textureMapper)
+{
+ if (!m_pendingSize.isZero()) {
+ m_size = m_pendingSize;
+ m_pendingSize = FloatSize();
+ }
+
+ for (auto& tileToRemove : m_tilesToRemove)
+ m_tiles.remove(tileToRemove);
+ m_tilesToRemove.clear();
+
+ for (auto& tile : m_tiles.values())
+ tile.swapBuffers(textureMapper);
+}
+
+} // namespace WebCore
+#endif // USE(COORDINATED_GRAPHICS)
</ins></span></pre></div>
<a id="trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedBackingStorehfromrev176945trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStoreh"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.h (from rev 176945, trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h) (0 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.h (rev 0)
+++ trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.h 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -0,0 +1,93 @@
</span><ins>+/*
+ Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+ */
+
+#ifndef CoordinatedBackingStore_h
+#define CoordinatedBackingStore_h
+
+#if USE(COORDINATED_GRAPHICS)
+
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperTile.h>
+#include <wtf/HashMap.h>
+#include <wtf/HashSet.h>
+
+
+namespace WebCore {
+class CoordinatedSurface;
+}
+
+namespace WebKit {
+
+class CoordinatedBackingStoreTile : public WebCore::TextureMapperTile {
+public:
+ explicit CoordinatedBackingStoreTile(float scale = 1)
+ : WebCore::TextureMapperTile(WebCore::FloatRect())
+ , m_scale(scale)
+ {
+ }
+
+ inline float scale() const { return m_scale; }
+ void swapBuffers(WebCore::TextureMapper*);
+ void setBackBuffer(const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface> buffer, const WebCore::IntPoint&);
+
+private:
+ RefPtr<WebCore::CoordinatedSurface> m_surface;
+ WebCore::IntRect m_sourceRect;
+ WebCore::IntRect m_tileRect;
+ WebCore::IntPoint m_surfaceOffset;
+ float m_scale;
+};
+
+class CoordinatedBackingStore : public WebCore::TextureMapperBackingStore {
+public:
+ void createTile(uint32_t tileID, float);
+ void removeTile(uint32_t tileID);
+ void removeAllTiles();
+ void updateTile(uint32_t tileID, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface>, const WebCore::IntPoint&);
+ static PassRefPtr<CoordinatedBackingStore> create() { return adoptRef(new CoordinatedBackingStore); }
+ void commitTileOperations(WebCore::TextureMapper*);
+ PassRefPtr<WebCore::BitmapTexture> texture() const;
+ void setSize(const WebCore::FloatSize&);
+ virtual void paintToTextureMapper(WebCore::TextureMapper*, const WebCore::FloatRect&, const WebCore::TransformationMatrix&, float);
+ virtual void drawBorder(WebCore::TextureMapper*, const WebCore::Color&, float borderWidth, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
+ virtual void drawRepaintCounter(WebCore::TextureMapper*, int repaintCount, const WebCore::Color&, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
+
+private:
+ CoordinatedBackingStore()
+ : m_scale(1.)
+ { }
+ void paintTilesToTextureMapper(Vector<WebCore::TextureMapperTile*>&, WebCore::TextureMapper*, const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&);
+ WebCore::TransformationMatrix adjustedTransformForRect(const WebCore::FloatRect&);
+ WebCore::FloatRect rect() const { return WebCore::FloatRect(WebCore::FloatPoint::zero(), m_size); }
+
+ typedef HashMap<uint32_t, CoordinatedBackingStoreTile> CoordinatedBackingStoreTileMap;
+ CoordinatedBackingStoreTileMap m_tiles;
+ HashSet<uint32_t> m_tilesToRemove;
+ // FIXME: m_pendingSize should be removed after the following bug is fixed: https://bugs.webkit.org/show_bug.cgi?id=108294
+ WebCore::FloatSize m_pendingSize;
+ WebCore::FloatSize m_size;
+ float m_scale;
+};
+
+} // namespace WebKit
+
+#endif // USE(COORDINATED_GRAPHICS)
+
+#endif // CoordinatedBackingStore_h
</ins></span></pre></div>
<a id="trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedGraphicsScenecppfromrev176945trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsScenecpp"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp (from rev 176945, trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp) (0 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp (rev 0)
+++ trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.cpp 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -0,0 +1,716 @@
</span><ins>+/*
+ Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
+ Copyright (C) 2012 Company 100, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+
+#if USE(COORDINATED_GRAPHICS)
+#include "CoordinatedGraphicsScene.h"
+
+#include "CoordinatedBackingStore.h"
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperGL.h>
+#include <WebCore/TextureMapperLayer.h>
+#include <wtf/Atomics.h>
+#include <wtf/MainThread.h>
+
+using namespace WebCore;
+
+namespace WebKit {
+
+void CoordinatedGraphicsScene::dispatchOnMainThread(std::function<void()> function)
+{
+ if (isMainThread())
+ function();
+ else
+ callOnMainThread(WTF::move(function));
+}
+
+static bool layerShouldHaveBackingStore(TextureMapperLayer* layer)
+{
+ return layer->drawsContent() && layer->contentsAreVisible() && !layer->size().isEmpty();
+}
+
+CoordinatedGraphicsScene::CoordinatedGraphicsScene(CoordinatedGraphicsSceneClient* client)
+ : m_client(client)
+ , m_isActive(false)
+ , m_rootLayerID(InvalidCoordinatedLayerID)
+ , m_viewBackgroundColor(Color::white)
+{
+ ASSERT(isMainThread());
+}
+
+CoordinatedGraphicsScene::~CoordinatedGraphicsScene()
+{
+}
+
+void CoordinatedGraphicsScene::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect, const Color& backgroundColor, bool drawsBackground, const FloatPoint& contentPosition, TextureMapper::PaintFlags PaintFlags)
+{
+ if (!m_textureMapper) {
+ m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
+ static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
+ }
+
+ ASSERT(m_textureMapper->accelerationMode() == TextureMapper::OpenGLMode);
+ syncRemoteContent();
+
+ adjustPositionForFixedLayers(contentPosition);
+ TextureMapperLayer* currentRootLayer = rootLayer();
+ if (!currentRootLayer)
+ return;
+
+ currentRootLayer->setTextureMapper(m_textureMapper.get());
+ currentRootLayer->applyAnimationsRecursively();
+ m_textureMapper->beginPainting(PaintFlags);
+ m_textureMapper->beginClip(TransformationMatrix(), clipRect);
+
+ if (drawsBackground) {
+ RGBA32 rgba = makeRGBA32FromFloats(backgroundColor.red(),
+ backgroundColor.green(), backgroundColor.blue(),
+ backgroundColor.alpha() * opacity);
+ m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), Color(rgba));
+ } else {
+ GraphicsContext3D* context = static_cast<TextureMapperGL*>(m_textureMapper.get())->graphicsContext3D();
+ context->clearColor(m_viewBackgroundColor.red() / 255.0f, m_viewBackgroundColor.green() / 255.0f, m_viewBackgroundColor.blue() / 255.0f, m_viewBackgroundColor.alpha() / 255.0f);
+ context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
+ }
+
+ if (currentRootLayer->opacity() != opacity || currentRootLayer->transform() != matrix) {
+ currentRootLayer->setOpacity(opacity);
+ currentRootLayer->setTransform(matrix);
+ }
+
+ currentRootLayer->paint();
+ m_fpsCounter.updateFPSAndDisplay(m_textureMapper.get(), clipRect.location(), matrix);
+ m_textureMapper->endClip();
+ m_textureMapper->endPainting();
+
+ if (currentRootLayer->descendantsOrSelfHaveRunningAnimations()) {
+ RefPtr<CoordinatedGraphicsScene> protector(this);
+ dispatchOnMainThread([=] {
+ protector->updateViewport();
+ });
+ }
+}
+
+void CoordinatedGraphicsScene::paintToGraphicsContext(PlatformGraphicsContext* platformContext, const Color& backgroundColor, bool drawsBackground)
+{
+ if (!m_textureMapper)
+ m_textureMapper = TextureMapper::create();
+ ASSERT(m_textureMapper->accelerationMode() == TextureMapper::SoftwareMode);
+ syncRemoteContent();
+ TextureMapperLayer* layer = rootLayer();
+
+ if (!layer)
+ return;
+
+ GraphicsContext graphicsContext(platformContext);
+ m_textureMapper->setGraphicsContext(&graphicsContext);
+ m_textureMapper->beginPainting();
+
+ IntRect clipRect = graphicsContext.clipBounds();
+ if (drawsBackground)
+ m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), backgroundColor);
+ else
+ m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), m_viewBackgroundColor);
+
+ layer->paint();
+ m_fpsCounter.updateFPSAndDisplay(m_textureMapper.get(), clipRect.location());
+ m_textureMapper->endPainting();
+ m_textureMapper->setGraphicsContext(0);
+}
+
+void CoordinatedGraphicsScene::updateViewport()
+{
+ ASSERT(isMainThread());
+ if (m_client)
+ m_client->updateViewport();
+}
+
+void CoordinatedGraphicsScene::adjustPositionForFixedLayers(const FloatPoint& contentPosition)
+{
+ if (m_fixedLayers.isEmpty())
+ return;
+
+ // Fixed layer positions are updated by the web process when we update the visible contents rect / scroll position.
+ // If we want those layers to follow accurately the viewport when we move between the web process updates, we have to offset
+ // them by the delta between the current position and the position of the viewport used for the last layout.
+ FloatSize delta = contentPosition - m_renderedContentsScrollPosition;
+
+ for (auto& fixedLayer : m_fixedLayers.values())
+ fixedLayer->setScrollPositionDeltaIfNeeded(delta);
+}
+
+#if USE(GRAPHICS_SURFACE)
+void CoordinatedGraphicsScene::createPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (!state.platformLayerToken.isValid())
+ return;
+
+ RefPtr<TextureMapperSurfaceBackingStore> platformLayerBackingStore(TextureMapperSurfaceBackingStore::create());
+ m_surfaceBackingStores.set(layer, platformLayerBackingStore);
+ platformLayerBackingStore->setGraphicsSurface(GraphicsSurface::create(state.platformLayerSize, state.platformLayerSurfaceFlags, state.platformLayerToken));
+ layer->setContentsLayer(platformLayerBackingStore.get());
+}
+
+void CoordinatedGraphicsScene::syncPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ ASSERT(m_textureMapper);
+
+ if (state.platformLayerChanged) {
+ destroyPlatformLayerIfNeeded(layer, state);
+ createPlatformLayerIfNeeded(layer, state);
+ }
+
+ if (state.platformLayerShouldSwapBuffers) {
+ ASSERT(m_surfaceBackingStores.contains(layer));
+ SurfaceBackingStoreMap::iterator it = m_surfaceBackingStores.find(layer);
+ RefPtr<TextureMapperSurfaceBackingStore> platformLayerBackingStore = it->value;
+ platformLayerBackingStore->swapBuffersIfNeeded(state.platformLayerFrontBuffer);
+ }
+}
+
+void CoordinatedGraphicsScene::destroyPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (state.platformLayerToken.isValid())
+ return;
+
+ m_surfaceBackingStores.remove(layer);
+ layer->setContentsLayer(0);
+}
+#endif
+
+void CoordinatedGraphicsScene::setLayerRepaintCountIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (!layer->isShowingRepaintCounter() || !state.repaintCountChanged)
+ return;
+
+ layer->setRepaintCount(state.repaintCount);
+}
+
+void CoordinatedGraphicsScene::setLayerChildrenIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (!state.childrenChanged)
+ return;
+
+ Vector<TextureMapperLayer*> children;
+
+ for (auto& child : state.children) {
+ TextureMapperLayer* childLayer = layerByID(child);
+ children.append(childLayer);
+ }
+ layer->setChildren(children);
+}
+
+void CoordinatedGraphicsScene::setLayerFiltersIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (!state.filtersChanged)
+ return;
+
+ layer->setFilters(state.filters);
+}
+
+void CoordinatedGraphicsScene::setLayerState(CoordinatedLayerID id, const CoordinatedGraphicsLayerState& layerState)
+{
+ ASSERT(m_rootLayerID != InvalidCoordinatedLayerID);
+ TextureMapperLayer* layer = layerByID(id);
+
+ if (layerState.positionChanged)
+ layer->setPosition(layerState.pos);
+
+ if (layerState.anchorPointChanged)
+ layer->setAnchorPoint(layerState.anchorPoint);
+
+ if (layerState.sizeChanged)
+ layer->setSize(layerState.size);
+
+ if (layerState.transformChanged)
+ layer->setTransform(layerState.transform);
+
+ if (layerState.childrenTransformChanged)
+ layer->setChildrenTransform(layerState.childrenTransform);
+
+ if (layerState.contentsRectChanged)
+ layer->setContentsRect(layerState.contentsRect);
+
+ if (layerState.contentsTilingChanged) {
+ layer->setContentsTilePhase(layerState.contentsTilePhase);
+ layer->setContentsTileSize(layerState.contentsTileSize);
+ }
+
+ if (layerState.opacityChanged)
+ layer->setOpacity(layerState.opacity);
+
+ if (layerState.solidColorChanged)
+ layer->setSolidColor(layerState.solidColor);
+
+ if (layerState.debugBorderColorChanged || layerState.debugBorderWidthChanged)
+ layer->setDebugVisuals(layerState.showDebugBorders, layerState.debugBorderColor, layerState.debugBorderWidth, layerState.showRepaintCounter);
+
+ if (layerState.replicaChanged)
+ layer->setReplicaLayer(getLayerByIDIfExists(layerState.replica));
+
+ if (layerState.maskChanged)
+ layer->setMaskLayer(getLayerByIDIfExists(layerState.mask));
+
+ if (layerState.imageChanged)
+ assignImageBackingToLayer(layer, layerState.imageID);
+
+ if (layerState.flagsChanged) {
+ layer->setContentsOpaque(layerState.contentsOpaque);
+ layer->setDrawsContent(layerState.drawsContent);
+ layer->setContentsVisible(layerState.contentsVisible);
+ layer->setBackfaceVisibility(layerState.backfaceVisible);
+
+ // Never clip the root layer.
+ layer->setMasksToBounds(id == m_rootLayerID ? false : layerState.masksToBounds);
+ layer->setPreserves3D(layerState.preserves3D);
+
+ bool fixedToViewportChanged = layer->fixedToViewport() != layerState.fixedToViewport;
+ layer->setFixedToViewport(layerState.fixedToViewport);
+ if (fixedToViewportChanged) {
+ if (layerState.fixedToViewport)
+ m_fixedLayers.add(id, layer);
+ else
+ m_fixedLayers.remove(id);
+ }
+
+ layer->setIsScrollable(layerState.isScrollable);
+ }
+
+ if (layerState.committedScrollOffsetChanged)
+ layer->didCommitScrollOffset(layerState.committedScrollOffset);
+
+ prepareContentBackingStore(layer);
+
+ // Apply Operations.
+ setLayerChildrenIfNeeded(layer, layerState);
+ createTilesIfNeeded(layer, layerState);
+ removeTilesIfNeeded(layer, layerState);
+ updateTilesIfNeeded(layer, layerState);
+ setLayerFiltersIfNeeded(layer, layerState);
+ setLayerAnimationsIfNeeded(layer, layerState);
+#if USE(GRAPHICS_SURFACE)
+ syncPlatformLayerIfNeeded(layer, layerState);
+#endif
+ setLayerRepaintCountIfNeeded(layer, layerState);
+}
+
+TextureMapperLayer* CoordinatedGraphicsScene::getLayerByIDIfExists(CoordinatedLayerID id)
+{
+ return (id != InvalidCoordinatedLayerID) ? layerByID(id) : 0;
+}
+
+void CoordinatedGraphicsScene::createLayers(const Vector<CoordinatedLayerID>& layerIDs)
+{
+ for (auto& layerID : layerIDs)
+ createLayer(layerID);
+}
+
+void CoordinatedGraphicsScene::createLayer(CoordinatedLayerID id)
+{
+ std::unique_ptr<TextureMapperLayer> newLayer = std::make_unique<TextureMapperLayer>();
+ newLayer->setID(id);
+ newLayer->setScrollClient(this);
+ m_layers.add(id, WTF::move(newLayer));
+}
+
+void CoordinatedGraphicsScene::deleteLayers(const Vector<CoordinatedLayerID>& layerIDs)
+{
+ for (auto& layerID : layerIDs)
+ deleteLayer(layerID);
+}
+
+void CoordinatedGraphicsScene::deleteLayer(CoordinatedLayerID layerID)
+{
+ std::unique_ptr<TextureMapperLayer> layer = m_layers.take(layerID);
+ ASSERT(layer);
+
+ m_backingStores.remove(layer.get());
+ m_fixedLayers.remove(layerID);
+#if USE(GRAPHICS_SURFACE)
+ m_surfaceBackingStores.remove(layer.get());
+#endif
+}
+
+void CoordinatedGraphicsScene::setRootLayerID(CoordinatedLayerID layerID)
+{
+ ASSERT(layerID != InvalidCoordinatedLayerID);
+ ASSERT(m_rootLayerID == InvalidCoordinatedLayerID);
+
+ m_rootLayerID = layerID;
+
+ TextureMapperLayer* layer = layerByID(layerID);
+ ASSERT(m_rootLayer->children().isEmpty());
+ m_rootLayer->addChild(layer);
+}
+
+void CoordinatedGraphicsScene::prepareContentBackingStore(TextureMapperLayer* layer)
+{
+ if (!layerShouldHaveBackingStore(layer)) {
+ removeBackingStoreIfNeeded(layer);
+ return;
+ }
+
+ createBackingStoreIfNeeded(layer);
+ resetBackingStoreSizeToLayerSize(layer);
+}
+
+void CoordinatedGraphicsScene::createBackingStoreIfNeeded(TextureMapperLayer* layer)
+{
+ if (m_backingStores.contains(layer))
+ return;
+
+ RefPtr<CoordinatedBackingStore> backingStore(CoordinatedBackingStore::create());
+ m_backingStores.add(layer, backingStore);
+ layer->setBackingStore(backingStore);
+}
+
+void CoordinatedGraphicsScene::removeBackingStoreIfNeeded(TextureMapperLayer* layer)
+{
+ RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.take(layer);
+ if (!backingStore)
+ return;
+
+ layer->setBackingStore(0);
+}
+
+void CoordinatedGraphicsScene::resetBackingStoreSizeToLayerSize(TextureMapperLayer* layer)
+{
+ RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
+ ASSERT(backingStore);
+ backingStore->setSize(layer->size());
+ m_backingStoresWithPendingBuffers.add(backingStore);
+}
+
+void CoordinatedGraphicsScene::createTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (state.tilesToCreate.isEmpty())
+ return;
+
+ RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
+ ASSERT(backingStore);
+
+ for (auto& tile : state.tilesToCreate)
+ backingStore->createTile(tile.tileID, tile.scale);
+}
+
+void CoordinatedGraphicsScene::removeTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (state.tilesToRemove.isEmpty())
+ return;
+
+ RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
+ if (!backingStore)
+ return;
+
+ for (auto& tile : state.tilesToRemove)
+ backingStore->removeTile(tile);
+
+ m_backingStoresWithPendingBuffers.add(backingStore);
+}
+
+void CoordinatedGraphicsScene::updateTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (state.tilesToUpdate.isEmpty())
+ return;
+
+ RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
+ ASSERT(backingStore);
+
+ for (auto& tile : state.tilesToUpdate) {
+ const SurfaceUpdateInfo& surfaceUpdateInfo = tile.updateInfo;
+
+ SurfaceMap::iterator surfaceIt = m_surfaces.find(surfaceUpdateInfo.atlasID);
+ ASSERT(surfaceIt != m_surfaces.end());
+
+ backingStore->updateTile(tile.tileID, surfaceUpdateInfo.updateRect, tile.tileRect, surfaceIt->value, surfaceUpdateInfo.surfaceOffset);
+ m_backingStoresWithPendingBuffers.add(backingStore);
+ }
+}
+
+void CoordinatedGraphicsScene::syncUpdateAtlases(const CoordinatedGraphicsState& state)
+{
+ for (auto& atlas : state.updateAtlasesToCreate)
+ createUpdateAtlas(atlas.first, atlas.second);
+
+ for (auto& atlas : state.updateAtlasesToRemove)
+ removeUpdateAtlas(atlas);
+}
+
+void CoordinatedGraphicsScene::createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface> surface)
+{
+ ASSERT(!m_surfaces.contains(atlasID));
+ m_surfaces.add(atlasID, surface);
+}
+
+void CoordinatedGraphicsScene::removeUpdateAtlas(uint32_t atlasID)
+{
+ ASSERT(m_surfaces.contains(atlasID));
+ m_surfaces.remove(atlasID);
+}
+
+void CoordinatedGraphicsScene::syncImageBackings(const CoordinatedGraphicsState& state)
+{
+ for (auto& image : state.imagesToRemove)
+ removeImageBacking(image);
+
+ for (auto& image : state.imagesToCreate)
+ createImageBacking(image);
+
+ for (auto& image : state.imagesToUpdate)
+ updateImageBacking(image.first, image.second);
+
+ for (auto& image : state.imagesToClear)
+ clearImageBackingContents(image);
+}
+
+void CoordinatedGraphicsScene::createImageBacking(CoordinatedImageBackingID imageID)
+{
+ ASSERT(!m_imageBackings.contains(imageID));
+ RefPtr<CoordinatedBackingStore> backingStore(CoordinatedBackingStore::create());
+ m_imageBackings.add(imageID, backingStore.release());
+}
+
+void CoordinatedGraphicsScene::updateImageBacking(CoordinatedImageBackingID imageID, PassRefPtr<CoordinatedSurface> surface)
+{
+ ASSERT(m_imageBackings.contains(imageID));
+ ImageBackingMap::iterator it = m_imageBackings.find(imageID);
+ RefPtr<CoordinatedBackingStore> backingStore = it->value;
+
+ // CoordinatedImageBacking is realized to CoordinatedBackingStore with only one tile in UI Process.
+ backingStore->createTile(1 /* id */, 1 /* scale */);
+ IntRect rect(IntPoint::zero(), surface->size());
+ // See CoordinatedGraphicsLayer::shouldDirectlyCompositeImage()
+ ASSERT(2000 >= std::max(rect.width(), rect.height()));
+ backingStore->setSize(rect.size());
+ backingStore->updateTile(1 /* id */, rect, rect, surface, rect.location());
+
+ m_backingStoresWithPendingBuffers.add(backingStore);
+}
+
+void CoordinatedGraphicsScene::clearImageBackingContents(CoordinatedImageBackingID imageID)
+{
+ ASSERT(m_imageBackings.contains(imageID));
+ ImageBackingMap::iterator it = m_imageBackings.find(imageID);
+ RefPtr<CoordinatedBackingStore> backingStore = it->value;
+ backingStore->removeAllTiles();
+ m_backingStoresWithPendingBuffers.add(backingStore);
+}
+
+void CoordinatedGraphicsScene::removeImageBacking(CoordinatedImageBackingID imageID)
+{
+ ASSERT(m_imageBackings.contains(imageID));
+
+ // We don't want TextureMapperLayer refers a dangling pointer.
+ m_releasedImageBackings.append(m_imageBackings.take(imageID));
+}
+
+void CoordinatedGraphicsScene::assignImageBackingToLayer(TextureMapperLayer* layer, CoordinatedImageBackingID imageID)
+{
+#if USE(GRAPHICS_SURFACE)
+ if (m_surfaceBackingStores.contains(layer))
+ return;
+#endif
+
+ if (imageID == InvalidCoordinatedImageBackingID) {
+ layer->setContentsLayer(0);
+ return;
+ }
+
+ ImageBackingMap::iterator it = m_imageBackings.find(imageID);
+ ASSERT(it != m_imageBackings.end());
+ layer->setContentsLayer(it->value.get());
+}
+
+void CoordinatedGraphicsScene::removeReleasedImageBackingsIfNeeded()
+{
+ m_releasedImageBackings.clear();
+}
+
+void CoordinatedGraphicsScene::commitPendingBackingStoreOperations()
+{
+ for (auto& backingStore : m_backingStoresWithPendingBuffers)
+ backingStore->commitTileOperations(m_textureMapper.get());
+
+ m_backingStoresWithPendingBuffers.clear();
+}
+
+void CoordinatedGraphicsScene::commitSceneState(const CoordinatedGraphicsState& state)
+{
+ m_renderedContentsScrollPosition = state.scrollPosition;
+
+ createLayers(state.layersToCreate);
+ deleteLayers(state.layersToRemove);
+
+ if (state.rootCompositingLayer != m_rootLayerID)
+ setRootLayerID(state.rootCompositingLayer);
+
+ syncImageBackings(state);
+ syncUpdateAtlases(state);
+
+ for (auto& layer : state.layersToUpdate)
+ setLayerState(layer.first, layer.second);
+
+ commitPendingBackingStoreOperations();
+ removeReleasedImageBackingsIfNeeded();
+
+ // The pending tiles state is on its way for the screen, tell the web process to render the next one.
+ RefPtr<CoordinatedGraphicsScene> protector(this);
+ dispatchOnMainThread([=] {
+ protector->renderNextFrame();
+ });
+}
+
+void CoordinatedGraphicsScene::renderNextFrame()
+{
+ if (m_client)
+ m_client->renderNextFrame();
+}
+
+void CoordinatedGraphicsScene::ensureRootLayer()
+{
+ if (m_rootLayer)
+ return;
+
+ m_rootLayer = std::make_unique<TextureMapperLayer>();
+ m_rootLayer->setMasksToBounds(false);
+ m_rootLayer->setDrawsContent(false);
+ m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
+
+ // The root layer should not have zero size, or it would be optimized out.
+ m_rootLayer->setSize(FloatSize(1.0, 1.0));
+
+ ASSERT(m_textureMapper);
+ m_rootLayer->setTextureMapper(m_textureMapper.get());
+}
+
+void CoordinatedGraphicsScene::syncRemoteContent()
+{
+ // We enqueue messages and execute them during paint, as they require an active GL context.
+ ensureRootLayer();
+
+ Vector<std::function<void()>> renderQueue;
+ bool calledOnMainThread = WTF::isMainThread();
+ if (!calledOnMainThread)
+ m_renderQueueMutex.lock();
+ renderQueue = WTF::move(m_renderQueue);
+ if (!calledOnMainThread)
+ m_renderQueueMutex.unlock();
+
+ for (auto& function : renderQueue)
+ function();
+}
+
+void CoordinatedGraphicsScene::purgeGLResources()
+{
+ m_imageBackings.clear();
+ m_releasedImageBackings.clear();
+#if USE(GRAPHICS_SURFACE)
+ m_surfaceBackingStores.clear();
+#endif
+ m_surfaces.clear();
+
+ m_rootLayer = nullptr;
+ m_rootLayerID = InvalidCoordinatedLayerID;
+ m_layers.clear();
+ m_fixedLayers.clear();
+ m_textureMapper = nullptr;
+ m_backingStores.clear();
+ m_backingStoresWithPendingBuffers.clear();
+
+ setActive(false);
+
+ RefPtr<CoordinatedGraphicsScene> protector(this);
+ dispatchOnMainThread([=] {
+ protector->purgeBackingStores();
+ });
+}
+
+void CoordinatedGraphicsScene::dispatchCommitScrollOffset(uint32_t layerID, const IntSize& offset)
+{
+ m_client->commitScrollOffset(layerID, offset);
+}
+
+void CoordinatedGraphicsScene::commitScrollOffset(uint32_t layerID, const IntSize& offset)
+{
+ RefPtr<CoordinatedGraphicsScene> protector(this);
+ dispatchOnMainThread([=] {
+ protector->dispatchCommitScrollOffset(layerID, offset);
+ });
+}
+
+void CoordinatedGraphicsScene::purgeBackingStores()
+{
+ if (m_client)
+ m_client->purgeBackingStores();
+}
+
+void CoordinatedGraphicsScene::setLayerAnimationsIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
+{
+ if (!state.animationsChanged)
+ return;
+
+ layer->setAnimations(state.animations);
+}
+
+void CoordinatedGraphicsScene::detach()
+{
+ ASSERT(isMainThread());
+ m_renderQueue.clear();
+ m_client = 0;
+}
+
+void CoordinatedGraphicsScene::appendUpdate(std::function<void()> function)
+{
+ if (!m_isActive)
+ return;
+
+ ASSERT(isMainThread());
+ MutexLocker locker(m_renderQueueMutex);
+ m_renderQueue.append(WTF::move(function));
+}
+
+void CoordinatedGraphicsScene::setActive(bool active)
+{
+ if (m_isActive == active)
+ return;
+
+ // Have to clear render queue in both cases.
+ // If there are some updates in queue during activation then those updates are from previous instance of paint node
+ // and cannot be applied to the newly created instance.
+ m_renderQueue.clear();
+ m_isActive = active;
+ if (m_isActive) {
+ RefPtr<CoordinatedGraphicsScene> protector(this);
+ dispatchOnMainThread([=] {
+ protector->renderNextFrame();
+ });
+ }
+}
+
+TextureMapperLayer* CoordinatedGraphicsScene::findScrollableContentsLayerAt(const FloatPoint& point)
+{
+ return rootLayer() ? rootLayer()->findScrollableContentsLayerAt(point) : 0;
+}
+
+} // namespace WebKit
+
+#endif // USE(COORDINATED_GRAPHICS)
</ins></span></pre></div>
<a id="trunkSourceWebKit2SharedCoordinatedGraphicsCoordinatedGraphicsScenehfromrev176945trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsSceneh"></a>
<div class="copfile"><h4>Copied: trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h (from rev 176945, trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h) (0 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h (rev 0)
+++ trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsScene.h 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -0,0 +1,192 @@
</span><ins>+/*
+ Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
+ Copyright (C) 2013 Company 100, Inc.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#ifndef CoordinatedGraphicsScene_h
+#define CoordinatedGraphicsScene_h
+
+#if USE(COORDINATED_GRAPHICS)
+#include <WebCore/CoordinatedGraphicsState.h>
+#include <WebCore/CoordinatedSurface.h>
+#include <WebCore/GraphicsContext.h>
+#include <WebCore/GraphicsLayer.h>
+#include <WebCore/GraphicsLayerAnimation.h>
+#include <WebCore/IntRect.h>
+#include <WebCore/IntSize.h>
+#include <WebCore/TextureMapper.h>
+#include <WebCore/TextureMapperBackingStore.h>
+#include <WebCore/TextureMapperFPSCounter.h>
+#include <WebCore/TextureMapperLayer.h>
+#include <WebCore/Timer.h>
+#include <functional>
+#include <wtf/HashSet.h>
+#include <wtf/ThreadingPrimitives.h>
+#include <wtf/Vector.h>
+
+#if USE(GRAPHICS_SURFACE)
+#include <WebCore/GraphicsSurface.h>
+#include <WebCore/TextureMapperSurfaceBackingStore.h>
+#endif
+
+namespace WebKit {
+
+class CoordinatedBackingStore;
+
+class CoordinatedGraphicsSceneClient {
+public:
+ virtual ~CoordinatedGraphicsSceneClient() { }
+ virtual void purgeBackingStores() = 0;
+ virtual void renderNextFrame() = 0;
+ virtual void updateViewport() = 0;
+ virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) = 0;
+};
+
+class CoordinatedGraphicsScene : public ThreadSafeRefCounted<CoordinatedGraphicsScene>, public WebCore::TextureMapperLayer::ScrollingClient {
+public:
+ explicit CoordinatedGraphicsScene(CoordinatedGraphicsSceneClient*);
+ virtual ~CoordinatedGraphicsScene();
+ void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&, const WebCore::Color& backgroundColor, bool drawsBackground, const WebCore::FloatPoint&, WebCore::TextureMapper::PaintFlags = 0);
+ void paintToGraphicsContext(PlatformGraphicsContext*, const WebCore::Color& backgroundColor, bool drawsBackground);
+ void detach();
+ void appendUpdate(std::function<void()>);
+
+ WebCore::TextureMapperLayer* findScrollableContentsLayerAt(const WebCore::FloatPoint&);
+
+ virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
+
+ // The painting thread must lock the main thread to use below two methods, because two methods access members that the main thread manages. See m_client.
+ // Currently, QQuickWebPage::updatePaintNode() locks the main thread before calling both methods.
+ void purgeGLResources();
+
+ bool isActive() const { return m_isActive; }
+ void setActive(bool);
+
+ void commitSceneState(const WebCore::CoordinatedGraphicsState&);
+
+ void setViewBackgroundColor(const WebCore::Color& color) { m_viewBackgroundColor = color; }
+ WebCore::Color viewBackgroundColor() const { return m_viewBackgroundColor; }
+
+private:
+ void setRootLayerID(WebCore::CoordinatedLayerID);
+ void createLayers(const Vector<WebCore::CoordinatedLayerID>&);
+ void deleteLayers(const Vector<WebCore::CoordinatedLayerID>&);
+ void setLayerState(WebCore::CoordinatedLayerID, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerChildrenIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void updateTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void createTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void removeTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerFiltersIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void setLayerAnimationsIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+#if USE(GRAPHICS_SURFACE)
+ void createPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void syncPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+ void destroyPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+#endif
+ void setLayerRepaintCountIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
+
+ void syncUpdateAtlases(const WebCore::CoordinatedGraphicsState&);
+ void createUpdateAtlas(uint32_t atlasID, PassRefPtr<WebCore::CoordinatedSurface>);
+ void removeUpdateAtlas(uint32_t atlasID);
+
+ void syncImageBackings(const WebCore::CoordinatedGraphicsState&);
+ void createImageBacking(WebCore::CoordinatedImageBackingID);
+ void updateImageBacking(WebCore::CoordinatedImageBackingID, PassRefPtr<WebCore::CoordinatedSurface>);
+ void clearImageBackingContents(WebCore::CoordinatedImageBackingID);
+ void removeImageBacking(WebCore::CoordinatedImageBackingID);
+
+ WebCore::TextureMapperLayer* layerByID(WebCore::CoordinatedLayerID id)
+ {
+ ASSERT(m_layers.contains(id));
+ ASSERT(id != WebCore::InvalidCoordinatedLayerID);
+ return m_layers.get(id);
+ }
+ WebCore::TextureMapperLayer* getLayerByIDIfExists(WebCore::CoordinatedLayerID);
+ WebCore::TextureMapperLayer* rootLayer() { return m_rootLayer.get(); }
+
+ void syncRemoteContent();
+ void adjustPositionForFixedLayers(const WebCore::FloatPoint& contentPosition);
+
+ void dispatchOnMainThread(std::function<void()>);
+ void updateViewport();
+ void renderNextFrame();
+ void purgeBackingStores();
+
+ void createLayer(WebCore::CoordinatedLayerID);
+ void deleteLayer(WebCore::CoordinatedLayerID);
+
+ void assignImageBackingToLayer(WebCore::TextureMapperLayer*, WebCore::CoordinatedImageBackingID);
+ void removeReleasedImageBackingsIfNeeded();
+ void ensureRootLayer();
+ void commitPendingBackingStoreOperations();
+
+ void prepareContentBackingStore(WebCore::TextureMapperLayer*);
+ void createBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
+ void removeBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
+ void resetBackingStoreSizeToLayerSize(WebCore::TextureMapperLayer*);
+
+ void dispatchCommitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
+
+ // Render queue can be accessed ony from main thread or updatePaintNode call stack!
+ Vector<std::function<void()>> m_renderQueue;
+ Mutex m_renderQueueMutex;
+
+ std::unique_ptr<WebCore::TextureMapper> m_textureMapper;
+
+ typedef HashMap<WebCore::CoordinatedImageBackingID, RefPtr<CoordinatedBackingStore>> ImageBackingMap;
+ ImageBackingMap m_imageBackings;
+ Vector<RefPtr<CoordinatedBackingStore>> m_releasedImageBackings;
+
+ typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<CoordinatedBackingStore>> BackingStoreMap;
+ BackingStoreMap m_backingStores;
+
+ HashSet<RefPtr<CoordinatedBackingStore>> m_backingStoresWithPendingBuffers;
+
+#if USE(GRAPHICS_SURFACE)
+ typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<WebCore::TextureMapperSurfaceBackingStore>> SurfaceBackingStoreMap;
+ SurfaceBackingStoreMap m_surfaceBackingStores;
+#endif
+
+ typedef HashMap<uint32_t /* atlasID */, RefPtr<WebCore::CoordinatedSurface>> SurfaceMap;
+ SurfaceMap m_surfaces;
+
+ // Below two members are accessed by only the main thread. The painting thread must lock the main thread to access both members.
+ CoordinatedGraphicsSceneClient* m_client;
+ bool m_isActive;
+
+ std::unique_ptr<WebCore::TextureMapperLayer> m_rootLayer;
+
+ typedef HashMap<WebCore::CoordinatedLayerID, std::unique_ptr<WebCore::TextureMapperLayer>> LayerMap;
+ LayerMap m_layers;
+ typedef HashMap<WebCore::CoordinatedLayerID, WebCore::TextureMapperLayer*> LayerRawPtrMap;
+ LayerRawPtrMap m_fixedLayers;
+ WebCore::CoordinatedLayerID m_rootLayerID;
+ WebCore::FloatPoint m_scrollPosition;
+ WebCore::FloatPoint m_renderedContentsScrollPosition;
+ WebCore::Color m_viewBackgroundColor;
+
+ WebCore::TextureMapperFPSCounter m_fpsCounter;
+};
+
+} // namespace WebKit
+
+#endif // USE(COORDINATED_GRAPHICS)
+
+#endif // CoordinatedGraphicsScene_h
+
+
</ins></span></pre></div>
<a id="trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStorecpp"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.cpp 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -1,188 +0,0 @@
</span><del>-/*
- Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Library General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public License
- along with this library; see the file COPYING.LIB. If not, write to
- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
- */
-
-#include "config.h"
-#include "CoordinatedBackingStore.h"
-
-#if USE(COORDINATED_GRAPHICS)
-#include <WebCore/CoordinatedSurface.h>
-#include <WebCore/GraphicsLayer.h>
-#include <WebCore/TextureMapper.h>
-#include <WebCore/TextureMapperGL.h>
-
-using namespace WebCore;
-
-namespace WebKit {
-
-void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper)
-{
- if (!m_surface)
- return;
-
- FloatRect tileRect(m_tileRect);
- tileRect.scale(1. / m_scale);
- bool shouldReset = false;
- if (tileRect != rect()) {
- setRect(tileRect);
- shouldReset = true;
- }
- RefPtr<BitmapTexture> texture = this->texture();
- if (!texture) {
- texture = textureMapper->createTexture();
- setTexture(texture.get());
- shouldReset = true;
- }
-
- ASSERT(textureMapper->maxTextureSize().width() >= m_tileRect.size().width());
- ASSERT(textureMapper->maxTextureSize().height() >= m_tileRect.size().height());
- if (shouldReset)
- texture->reset(m_tileRect.size(), m_surface->supportsAlpha());
-
- m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);
- m_surface.clear();
-}
-
-void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)
-{
- m_sourceRect = sourceRect;
- m_tileRect = tileRect;
- m_surfaceOffset = offset;
- m_surface = buffer;
-}
-
-void CoordinatedBackingStore::createTile(uint32_t id, float scale)
-{
- m_tiles.add(id, CoordinatedBackingStoreTile(scale));
- m_scale = scale;
-}
-
-void CoordinatedBackingStore::removeTile(uint32_t id)
-{
- ASSERT(m_tiles.contains(id));
- m_tilesToRemove.add(id);
-}
-
-void CoordinatedBackingStore::removeAllTiles()
-{
- for (auto& key : m_tiles.keys())
- m_tilesToRemove.add(key);
-}
-
-void CoordinatedBackingStore::updateTile(uint32_t id, const IntRect& sourceRect, const IntRect& tileRect, PassRefPtr<CoordinatedSurface> backBuffer, const IntPoint& offset)
-{
- CoordinatedBackingStoreTileMap::iterator it = m_tiles.find(id);
- ASSERT(it != m_tiles.end());
- it->value.setBackBuffer(tileRect, sourceRect, backBuffer, offset);
-}
-
-PassRefPtr<BitmapTexture> CoordinatedBackingStore::texture() const
-{
- for (auto& tile : m_tiles.values()) {
- RefPtr<BitmapTexture> texture = tile.texture();
- if (texture)
- return texture;
- }
-
- return PassRefPtr<BitmapTexture>();
-}
-
-void CoordinatedBackingStore::setSize(const FloatSize& size)
-{
- m_pendingSize = size;
-}
-
-void CoordinatedBackingStore::paintTilesToTextureMapper(Vector<TextureMapperTile*>& tiles, TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, const FloatRect& rect)
-{
- for (auto& tile : tiles)
- tile->paint(textureMapper, transform, opacity, calculateExposedTileEdges(rect, tile->rect()));
-}
-
-TransformationMatrix CoordinatedBackingStore::adjustedTransformForRect(const FloatRect& targetRect)
-{
- return TransformationMatrix::rectToRect(rect(), targetRect);
-}
-
-void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)
-{
- if (m_tiles.isEmpty())
- return;
- ASSERT(!m_size.isZero());
-
- Vector<TextureMapperTile*> tilesToPaint;
- Vector<TextureMapperTile*> previousTilesToPaint;
-
- // We have to do this every time we paint, in case the opacity has changed.
- FloatRect coveredRect;
- for (auto& tile : m_tiles.values()) {
- if (!tile.texture())
- continue;
-
- if (tile.scale() == m_scale) {
- tilesToPaint.append(&tile);
- coveredRect.unite(tile.rect());
- continue;
- }
-
- // Only show the previous tile if the opacity is high, otherwise effect looks like a bug.
- // We show the previous-scale tile anyway if it doesn't intersect with any current-scale tile.
- if (opacity < 0.95 && coveredRect.intersects(tile.rect()))
- continue;
-
- previousTilesToPaint.append(&tile);
- }
-
- // targetRect is on the contents coordinate system, so we must compare two rects on the contents coordinate system.
- // See TiledBackingStore.
- TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
-
- paintTilesToTextureMapper(previousTilesToPaint, textureMapper, adjustedTransform, opacity, rect());
- paintTilesToTextureMapper(tilesToPaint, textureMapper, adjustedTransform, opacity, rect());
-}
-
-void CoordinatedBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)
-{
- TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
- for (auto& tile : m_tiles.values())
- textureMapper->drawBorder(borderColor, borderWidth, tile.rect(), adjustedTransform);
-}
-
-void CoordinatedBackingStore::drawRepaintCounter(TextureMapper* textureMapper, int repaintCount, const Color& borderColor, const FloatRect& targetRect, const TransformationMatrix& transform)
-{
- TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
- for (auto& tile : m_tiles.values())
- textureMapper->drawNumber(repaintCount, borderColor, tile.rect().location(), adjustedTransform);
-}
-
-void CoordinatedBackingStore::commitTileOperations(TextureMapper* textureMapper)
-{
- if (!m_pendingSize.isZero()) {
- m_size = m_pendingSize;
- m_pendingSize = FloatSize();
- }
-
- for (auto& tileToRemove : m_tilesToRemove)
- m_tiles.remove(tileToRemove);
- m_tilesToRemove.clear();
-
- for (auto& tile : m_tiles.values())
- tile.swapBuffers(textureMapper);
-}
-
-} // namespace WebCore
-#endif // USE(COORDINATED_GRAPHICS)
</del></span></pre></div>
<a id="trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedBackingStoreh"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedBackingStore.h 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -1,93 +0,0 @@
</span><del>-/*
- Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Library General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public License
- along with this library; see the file COPYING.LIB. If not, write to
- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
- */
-
-#ifndef CoordinatedBackingStore_h
-#define CoordinatedBackingStore_h
-
-#if USE(COORDINATED_GRAPHICS)
-
-#include <WebCore/TextureMapper.h>
-#include <WebCore/TextureMapperBackingStore.h>
-#include <WebCore/TextureMapperTile.h>
-#include <wtf/HashMap.h>
-#include <wtf/HashSet.h>
-
-
-namespace WebCore {
-class CoordinatedSurface;
-}
-
-namespace WebKit {
-
-class CoordinatedBackingStoreTile : public WebCore::TextureMapperTile {
-public:
- explicit CoordinatedBackingStoreTile(float scale = 1)
- : WebCore::TextureMapperTile(WebCore::FloatRect())
- , m_scale(scale)
- {
- }
-
- inline float scale() const { return m_scale; }
- void swapBuffers(WebCore::TextureMapper*);
- void setBackBuffer(const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface> buffer, const WebCore::IntPoint&);
-
-private:
- RefPtr<WebCore::CoordinatedSurface> m_surface;
- WebCore::IntRect m_sourceRect;
- WebCore::IntRect m_tileRect;
- WebCore::IntPoint m_surfaceOffset;
- float m_scale;
-};
-
-class CoordinatedBackingStore : public WebCore::TextureMapperBackingStore {
-public:
- void createTile(uint32_t tileID, float);
- void removeTile(uint32_t tileID);
- void removeAllTiles();
- void updateTile(uint32_t tileID, const WebCore::IntRect&, const WebCore::IntRect&, PassRefPtr<WebCore::CoordinatedSurface>, const WebCore::IntPoint&);
- static PassRefPtr<CoordinatedBackingStore> create() { return adoptRef(new CoordinatedBackingStore); }
- void commitTileOperations(WebCore::TextureMapper*);
- PassRefPtr<WebCore::BitmapTexture> texture() const;
- void setSize(const WebCore::FloatSize&);
- virtual void paintToTextureMapper(WebCore::TextureMapper*, const WebCore::FloatRect&, const WebCore::TransformationMatrix&, float);
- virtual void drawBorder(WebCore::TextureMapper*, const WebCore::Color&, float borderWidth, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
- virtual void drawRepaintCounter(WebCore::TextureMapper*, int repaintCount, const WebCore::Color&, const WebCore::FloatRect&, const WebCore::TransformationMatrix&) override;
-
-private:
- CoordinatedBackingStore()
- : m_scale(1.)
- { }
- void paintTilesToTextureMapper(Vector<WebCore::TextureMapperTile*>&, WebCore::TextureMapper*, const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&);
- WebCore::TransformationMatrix adjustedTransformForRect(const WebCore::FloatRect&);
- WebCore::FloatRect rect() const { return WebCore::FloatRect(WebCore::FloatPoint::zero(), m_size); }
-
- typedef HashMap<uint32_t, CoordinatedBackingStoreTile> CoordinatedBackingStoreTileMap;
- CoordinatedBackingStoreTileMap m_tiles;
- HashSet<uint32_t> m_tilesToRemove;
- // FIXME: m_pendingSize should be removed after the following bug is fixed: https://bugs.webkit.org/show_bug.cgi?id=108294
- WebCore::FloatSize m_pendingSize;
- WebCore::FloatSize m_size;
- float m_scale;
-};
-
-} // namespace WebKit
-
-#endif // USE(COORDINATED_GRAPHICS)
-
-#endif // CoordinatedBackingStore_h
</del></span></pre></div>
<a id="trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsScenecpp"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.cpp 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -1,716 +0,0 @@
</span><del>-/*
- Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
- Copyright (C) 2012 Company 100, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Library General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public License
- along with this library; see the file COPYING.LIB. If not, write to
- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
-*/
-
-#include "config.h"
-
-#if USE(COORDINATED_GRAPHICS)
-#include "CoordinatedGraphicsScene.h"
-
-#include "CoordinatedBackingStore.h"
-#include <WebCore/TextureMapper.h>
-#include <WebCore/TextureMapperBackingStore.h>
-#include <WebCore/TextureMapperGL.h>
-#include <WebCore/TextureMapperLayer.h>
-#include <wtf/Atomics.h>
-#include <wtf/MainThread.h>
-
-using namespace WebCore;
-
-namespace WebKit {
-
-void CoordinatedGraphicsScene::dispatchOnMainThread(std::function<void()> function)
-{
- if (isMainThread())
- function();
- else
- callOnMainThread(WTF::move(function));
-}
-
-static bool layerShouldHaveBackingStore(TextureMapperLayer* layer)
-{
- return layer->drawsContent() && layer->contentsAreVisible() && !layer->size().isEmpty();
-}
-
-CoordinatedGraphicsScene::CoordinatedGraphicsScene(CoordinatedGraphicsSceneClient* client)
- : m_client(client)
- , m_isActive(false)
- , m_rootLayerID(InvalidCoordinatedLayerID)
- , m_viewBackgroundColor(Color::white)
-{
- ASSERT(isMainThread());
-}
-
-CoordinatedGraphicsScene::~CoordinatedGraphicsScene()
-{
-}
-
-void CoordinatedGraphicsScene::paintToCurrentGLContext(const TransformationMatrix& matrix, float opacity, const FloatRect& clipRect, const Color& backgroundColor, bool drawsBackground, const FloatPoint& contentPosition, TextureMapper::PaintFlags PaintFlags)
-{
- if (!m_textureMapper) {
- m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
- static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
- }
-
- ASSERT(m_textureMapper->accelerationMode() == TextureMapper::OpenGLMode);
- syncRemoteContent();
-
- adjustPositionForFixedLayers(contentPosition);
- TextureMapperLayer* currentRootLayer = rootLayer();
- if (!currentRootLayer)
- return;
-
- currentRootLayer->setTextureMapper(m_textureMapper.get());
- currentRootLayer->applyAnimationsRecursively();
- m_textureMapper->beginPainting(PaintFlags);
- m_textureMapper->beginClip(TransformationMatrix(), clipRect);
-
- if (drawsBackground) {
- RGBA32 rgba = makeRGBA32FromFloats(backgroundColor.red(),
- backgroundColor.green(), backgroundColor.blue(),
- backgroundColor.alpha() * opacity);
- m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), Color(rgba));
- } else {
- GraphicsContext3D* context = static_cast<TextureMapperGL*>(m_textureMapper.get())->graphicsContext3D();
- context->clearColor(m_viewBackgroundColor.red() / 255.0f, m_viewBackgroundColor.green() / 255.0f, m_viewBackgroundColor.blue() / 255.0f, m_viewBackgroundColor.alpha() / 255.0f);
- context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
- }
-
- if (currentRootLayer->opacity() != opacity || currentRootLayer->transform() != matrix) {
- currentRootLayer->setOpacity(opacity);
- currentRootLayer->setTransform(matrix);
- }
-
- currentRootLayer->paint();
- m_fpsCounter.updateFPSAndDisplay(m_textureMapper.get(), clipRect.location(), matrix);
- m_textureMapper->endClip();
- m_textureMapper->endPainting();
-
- if (currentRootLayer->descendantsOrSelfHaveRunningAnimations()) {
- RefPtr<CoordinatedGraphicsScene> protector(this);
- dispatchOnMainThread([=] {
- protector->updateViewport();
- });
- }
-}
-
-void CoordinatedGraphicsScene::paintToGraphicsContext(PlatformGraphicsContext* platformContext, const Color& backgroundColor, bool drawsBackground)
-{
- if (!m_textureMapper)
- m_textureMapper = TextureMapper::create();
- ASSERT(m_textureMapper->accelerationMode() == TextureMapper::SoftwareMode);
- syncRemoteContent();
- TextureMapperLayer* layer = rootLayer();
-
- if (!layer)
- return;
-
- GraphicsContext graphicsContext(platformContext);
- m_textureMapper->setGraphicsContext(&graphicsContext);
- m_textureMapper->beginPainting();
-
- IntRect clipRect = graphicsContext.clipBounds();
- if (drawsBackground)
- m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), backgroundColor);
- else
- m_textureMapper->drawSolidColor(clipRect, TransformationMatrix(), m_viewBackgroundColor);
-
- layer->paint();
- m_fpsCounter.updateFPSAndDisplay(m_textureMapper.get(), clipRect.location());
- m_textureMapper->endPainting();
- m_textureMapper->setGraphicsContext(0);
-}
-
-void CoordinatedGraphicsScene::updateViewport()
-{
- ASSERT(isMainThread());
- if (m_client)
- m_client->updateViewport();
-}
-
-void CoordinatedGraphicsScene::adjustPositionForFixedLayers(const FloatPoint& contentPosition)
-{
- if (m_fixedLayers.isEmpty())
- return;
-
- // Fixed layer positions are updated by the web process when we update the visible contents rect / scroll position.
- // If we want those layers to follow accurately the viewport when we move between the web process updates, we have to offset
- // them by the delta between the current position and the position of the viewport used for the last layout.
- FloatSize delta = contentPosition - m_renderedContentsScrollPosition;
-
- for (auto& fixedLayer : m_fixedLayers.values())
- fixedLayer->setScrollPositionDeltaIfNeeded(delta);
-}
-
-#if USE(GRAPHICS_SURFACE)
-void CoordinatedGraphicsScene::createPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (!state.platformLayerToken.isValid())
- return;
-
- RefPtr<TextureMapperSurfaceBackingStore> platformLayerBackingStore(TextureMapperSurfaceBackingStore::create());
- m_surfaceBackingStores.set(layer, platformLayerBackingStore);
- platformLayerBackingStore->setGraphicsSurface(GraphicsSurface::create(state.platformLayerSize, state.platformLayerSurfaceFlags, state.platformLayerToken));
- layer->setContentsLayer(platformLayerBackingStore.get());
-}
-
-void CoordinatedGraphicsScene::syncPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- ASSERT(m_textureMapper);
-
- if (state.platformLayerChanged) {
- destroyPlatformLayerIfNeeded(layer, state);
- createPlatformLayerIfNeeded(layer, state);
- }
-
- if (state.platformLayerShouldSwapBuffers) {
- ASSERT(m_surfaceBackingStores.contains(layer));
- SurfaceBackingStoreMap::iterator it = m_surfaceBackingStores.find(layer);
- RefPtr<TextureMapperSurfaceBackingStore> platformLayerBackingStore = it->value;
- platformLayerBackingStore->swapBuffersIfNeeded(state.platformLayerFrontBuffer);
- }
-}
-
-void CoordinatedGraphicsScene::destroyPlatformLayerIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (state.platformLayerToken.isValid())
- return;
-
- m_surfaceBackingStores.remove(layer);
- layer->setContentsLayer(0);
-}
-#endif
-
-void CoordinatedGraphicsScene::setLayerRepaintCountIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (!layer->isShowingRepaintCounter() || !state.repaintCountChanged)
- return;
-
- layer->setRepaintCount(state.repaintCount);
-}
-
-void CoordinatedGraphicsScene::setLayerChildrenIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (!state.childrenChanged)
- return;
-
- Vector<TextureMapperLayer*> children;
-
- for (auto& child : state.children) {
- TextureMapperLayer* childLayer = layerByID(child);
- children.append(childLayer);
- }
- layer->setChildren(children);
-}
-
-void CoordinatedGraphicsScene::setLayerFiltersIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (!state.filtersChanged)
- return;
-
- layer->setFilters(state.filters);
-}
-
-void CoordinatedGraphicsScene::setLayerState(CoordinatedLayerID id, const CoordinatedGraphicsLayerState& layerState)
-{
- ASSERT(m_rootLayerID != InvalidCoordinatedLayerID);
- TextureMapperLayer* layer = layerByID(id);
-
- if (layerState.positionChanged)
- layer->setPosition(layerState.pos);
-
- if (layerState.anchorPointChanged)
- layer->setAnchorPoint(layerState.anchorPoint);
-
- if (layerState.sizeChanged)
- layer->setSize(layerState.size);
-
- if (layerState.transformChanged)
- layer->setTransform(layerState.transform);
-
- if (layerState.childrenTransformChanged)
- layer->setChildrenTransform(layerState.childrenTransform);
-
- if (layerState.contentsRectChanged)
- layer->setContentsRect(layerState.contentsRect);
-
- if (layerState.contentsTilingChanged) {
- layer->setContentsTilePhase(layerState.contentsTilePhase);
- layer->setContentsTileSize(layerState.contentsTileSize);
- }
-
- if (layerState.opacityChanged)
- layer->setOpacity(layerState.opacity);
-
- if (layerState.solidColorChanged)
- layer->setSolidColor(layerState.solidColor);
-
- if (layerState.debugBorderColorChanged || layerState.debugBorderWidthChanged)
- layer->setDebugVisuals(layerState.showDebugBorders, layerState.debugBorderColor, layerState.debugBorderWidth, layerState.showRepaintCounter);
-
- if (layerState.replicaChanged)
- layer->setReplicaLayer(getLayerByIDIfExists(layerState.replica));
-
- if (layerState.maskChanged)
- layer->setMaskLayer(getLayerByIDIfExists(layerState.mask));
-
- if (layerState.imageChanged)
- assignImageBackingToLayer(layer, layerState.imageID);
-
- if (layerState.flagsChanged) {
- layer->setContentsOpaque(layerState.contentsOpaque);
- layer->setDrawsContent(layerState.drawsContent);
- layer->setContentsVisible(layerState.contentsVisible);
- layer->setBackfaceVisibility(layerState.backfaceVisible);
-
- // Never clip the root layer.
- layer->setMasksToBounds(id == m_rootLayerID ? false : layerState.masksToBounds);
- layer->setPreserves3D(layerState.preserves3D);
-
- bool fixedToViewportChanged = layer->fixedToViewport() != layerState.fixedToViewport;
- layer->setFixedToViewport(layerState.fixedToViewport);
- if (fixedToViewportChanged) {
- if (layerState.fixedToViewport)
- m_fixedLayers.add(id, layer);
- else
- m_fixedLayers.remove(id);
- }
-
- layer->setIsScrollable(layerState.isScrollable);
- }
-
- if (layerState.committedScrollOffsetChanged)
- layer->didCommitScrollOffset(layerState.committedScrollOffset);
-
- prepareContentBackingStore(layer);
-
- // Apply Operations.
- setLayerChildrenIfNeeded(layer, layerState);
- createTilesIfNeeded(layer, layerState);
- removeTilesIfNeeded(layer, layerState);
- updateTilesIfNeeded(layer, layerState);
- setLayerFiltersIfNeeded(layer, layerState);
- setLayerAnimationsIfNeeded(layer, layerState);
-#if USE(GRAPHICS_SURFACE)
- syncPlatformLayerIfNeeded(layer, layerState);
-#endif
- setLayerRepaintCountIfNeeded(layer, layerState);
-}
-
-TextureMapperLayer* CoordinatedGraphicsScene::getLayerByIDIfExists(CoordinatedLayerID id)
-{
- return (id != InvalidCoordinatedLayerID) ? layerByID(id) : 0;
-}
-
-void CoordinatedGraphicsScene::createLayers(const Vector<CoordinatedLayerID>& layerIDs)
-{
- for (auto& layerID : layerIDs)
- createLayer(layerID);
-}
-
-void CoordinatedGraphicsScene::createLayer(CoordinatedLayerID id)
-{
- std::unique_ptr<TextureMapperLayer> newLayer = std::make_unique<TextureMapperLayer>();
- newLayer->setID(id);
- newLayer->setScrollClient(this);
- m_layers.add(id, WTF::move(newLayer));
-}
-
-void CoordinatedGraphicsScene::deleteLayers(const Vector<CoordinatedLayerID>& layerIDs)
-{
- for (auto& layerID : layerIDs)
- deleteLayer(layerID);
-}
-
-void CoordinatedGraphicsScene::deleteLayer(CoordinatedLayerID layerID)
-{
- std::unique_ptr<TextureMapperLayer> layer = m_layers.take(layerID);
- ASSERT(layer);
-
- m_backingStores.remove(layer.get());
- m_fixedLayers.remove(layerID);
-#if USE(GRAPHICS_SURFACE)
- m_surfaceBackingStores.remove(layer.get());
-#endif
-}
-
-void CoordinatedGraphicsScene::setRootLayerID(CoordinatedLayerID layerID)
-{
- ASSERT(layerID != InvalidCoordinatedLayerID);
- ASSERT(m_rootLayerID == InvalidCoordinatedLayerID);
-
- m_rootLayerID = layerID;
-
- TextureMapperLayer* layer = layerByID(layerID);
- ASSERT(m_rootLayer->children().isEmpty());
- m_rootLayer->addChild(layer);
-}
-
-void CoordinatedGraphicsScene::prepareContentBackingStore(TextureMapperLayer* layer)
-{
- if (!layerShouldHaveBackingStore(layer)) {
- removeBackingStoreIfNeeded(layer);
- return;
- }
-
- createBackingStoreIfNeeded(layer);
- resetBackingStoreSizeToLayerSize(layer);
-}
-
-void CoordinatedGraphicsScene::createBackingStoreIfNeeded(TextureMapperLayer* layer)
-{
- if (m_backingStores.contains(layer))
- return;
-
- RefPtr<CoordinatedBackingStore> backingStore(CoordinatedBackingStore::create());
- m_backingStores.add(layer, backingStore);
- layer->setBackingStore(backingStore);
-}
-
-void CoordinatedGraphicsScene::removeBackingStoreIfNeeded(TextureMapperLayer* layer)
-{
- RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.take(layer);
- if (!backingStore)
- return;
-
- layer->setBackingStore(0);
-}
-
-void CoordinatedGraphicsScene::resetBackingStoreSizeToLayerSize(TextureMapperLayer* layer)
-{
- RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
- ASSERT(backingStore);
- backingStore->setSize(layer->size());
- m_backingStoresWithPendingBuffers.add(backingStore);
-}
-
-void CoordinatedGraphicsScene::createTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (state.tilesToCreate.isEmpty())
- return;
-
- RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
- ASSERT(backingStore);
-
- for (auto& tile : state.tilesToCreate)
- backingStore->createTile(tile.tileID, tile.scale);
-}
-
-void CoordinatedGraphicsScene::removeTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (state.tilesToRemove.isEmpty())
- return;
-
- RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
- if (!backingStore)
- return;
-
- for (auto& tile : state.tilesToRemove)
- backingStore->removeTile(tile);
-
- m_backingStoresWithPendingBuffers.add(backingStore);
-}
-
-void CoordinatedGraphicsScene::updateTilesIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (state.tilesToUpdate.isEmpty())
- return;
-
- RefPtr<CoordinatedBackingStore> backingStore = m_backingStores.get(layer);
- ASSERT(backingStore);
-
- for (auto& tile : state.tilesToUpdate) {
- const SurfaceUpdateInfo& surfaceUpdateInfo = tile.updateInfo;
-
- SurfaceMap::iterator surfaceIt = m_surfaces.find(surfaceUpdateInfo.atlasID);
- ASSERT(surfaceIt != m_surfaces.end());
-
- backingStore->updateTile(tile.tileID, surfaceUpdateInfo.updateRect, tile.tileRect, surfaceIt->value, surfaceUpdateInfo.surfaceOffset);
- m_backingStoresWithPendingBuffers.add(backingStore);
- }
-}
-
-void CoordinatedGraphicsScene::syncUpdateAtlases(const CoordinatedGraphicsState& state)
-{
- for (auto& atlas : state.updateAtlasesToCreate)
- createUpdateAtlas(atlas.first, atlas.second);
-
- for (auto& atlas : state.updateAtlasesToRemove)
- removeUpdateAtlas(atlas);
-}
-
-void CoordinatedGraphicsScene::createUpdateAtlas(uint32_t atlasID, PassRefPtr<CoordinatedSurface> surface)
-{
- ASSERT(!m_surfaces.contains(atlasID));
- m_surfaces.add(atlasID, surface);
-}
-
-void CoordinatedGraphicsScene::removeUpdateAtlas(uint32_t atlasID)
-{
- ASSERT(m_surfaces.contains(atlasID));
- m_surfaces.remove(atlasID);
-}
-
-void CoordinatedGraphicsScene::syncImageBackings(const CoordinatedGraphicsState& state)
-{
- for (auto& image : state.imagesToRemove)
- removeImageBacking(image);
-
- for (auto& image : state.imagesToCreate)
- createImageBacking(image);
-
- for (auto& image : state.imagesToUpdate)
- updateImageBacking(image.first, image.second);
-
- for (auto& image : state.imagesToClear)
- clearImageBackingContents(image);
-}
-
-void CoordinatedGraphicsScene::createImageBacking(CoordinatedImageBackingID imageID)
-{
- ASSERT(!m_imageBackings.contains(imageID));
- RefPtr<CoordinatedBackingStore> backingStore(CoordinatedBackingStore::create());
- m_imageBackings.add(imageID, backingStore.release());
-}
-
-void CoordinatedGraphicsScene::updateImageBacking(CoordinatedImageBackingID imageID, PassRefPtr<CoordinatedSurface> surface)
-{
- ASSERT(m_imageBackings.contains(imageID));
- ImageBackingMap::iterator it = m_imageBackings.find(imageID);
- RefPtr<CoordinatedBackingStore> backingStore = it->value;
-
- // CoordinatedImageBacking is realized to CoordinatedBackingStore with only one tile in UI Process.
- backingStore->createTile(1 /* id */, 1 /* scale */);
- IntRect rect(IntPoint::zero(), surface->size());
- // See CoordinatedGraphicsLayer::shouldDirectlyCompositeImage()
- ASSERT(2000 >= std::max(rect.width(), rect.height()));
- backingStore->setSize(rect.size());
- backingStore->updateTile(1 /* id */, rect, rect, surface, rect.location());
-
- m_backingStoresWithPendingBuffers.add(backingStore);
-}
-
-void CoordinatedGraphicsScene::clearImageBackingContents(CoordinatedImageBackingID imageID)
-{
- ASSERT(m_imageBackings.contains(imageID));
- ImageBackingMap::iterator it = m_imageBackings.find(imageID);
- RefPtr<CoordinatedBackingStore> backingStore = it->value;
- backingStore->removeAllTiles();
- m_backingStoresWithPendingBuffers.add(backingStore);
-}
-
-void CoordinatedGraphicsScene::removeImageBacking(CoordinatedImageBackingID imageID)
-{
- ASSERT(m_imageBackings.contains(imageID));
-
- // We don't want TextureMapperLayer refers a dangling pointer.
- m_releasedImageBackings.append(m_imageBackings.take(imageID));
-}
-
-void CoordinatedGraphicsScene::assignImageBackingToLayer(TextureMapperLayer* layer, CoordinatedImageBackingID imageID)
-{
-#if USE(GRAPHICS_SURFACE)
- if (m_surfaceBackingStores.contains(layer))
- return;
-#endif
-
- if (imageID == InvalidCoordinatedImageBackingID) {
- layer->setContentsLayer(0);
- return;
- }
-
- ImageBackingMap::iterator it = m_imageBackings.find(imageID);
- ASSERT(it != m_imageBackings.end());
- layer->setContentsLayer(it->value.get());
-}
-
-void CoordinatedGraphicsScene::removeReleasedImageBackingsIfNeeded()
-{
- m_releasedImageBackings.clear();
-}
-
-void CoordinatedGraphicsScene::commitPendingBackingStoreOperations()
-{
- for (auto& backingStore : m_backingStoresWithPendingBuffers)
- backingStore->commitTileOperations(m_textureMapper.get());
-
- m_backingStoresWithPendingBuffers.clear();
-}
-
-void CoordinatedGraphicsScene::commitSceneState(const CoordinatedGraphicsState& state)
-{
- m_renderedContentsScrollPosition = state.scrollPosition;
-
- createLayers(state.layersToCreate);
- deleteLayers(state.layersToRemove);
-
- if (state.rootCompositingLayer != m_rootLayerID)
- setRootLayerID(state.rootCompositingLayer);
-
- syncImageBackings(state);
- syncUpdateAtlases(state);
-
- for (auto& layer : state.layersToUpdate)
- setLayerState(layer.first, layer.second);
-
- commitPendingBackingStoreOperations();
- removeReleasedImageBackingsIfNeeded();
-
- // The pending tiles state is on its way for the screen, tell the web process to render the next one.
- RefPtr<CoordinatedGraphicsScene> protector(this);
- dispatchOnMainThread([=] {
- protector->renderNextFrame();
- });
-}
-
-void CoordinatedGraphicsScene::renderNextFrame()
-{
- if (m_client)
- m_client->renderNextFrame();
-}
-
-void CoordinatedGraphicsScene::ensureRootLayer()
-{
- if (m_rootLayer)
- return;
-
- m_rootLayer = std::make_unique<TextureMapperLayer>();
- m_rootLayer->setMasksToBounds(false);
- m_rootLayer->setDrawsContent(false);
- m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
-
- // The root layer should not have zero size, or it would be optimized out.
- m_rootLayer->setSize(FloatSize(1.0, 1.0));
-
- ASSERT(m_textureMapper);
- m_rootLayer->setTextureMapper(m_textureMapper.get());
-}
-
-void CoordinatedGraphicsScene::syncRemoteContent()
-{
- // We enqueue messages and execute them during paint, as they require an active GL context.
- ensureRootLayer();
-
- Vector<std::function<void()>> renderQueue;
- bool calledOnMainThread = WTF::isMainThread();
- if (!calledOnMainThread)
- m_renderQueueMutex.lock();
- renderQueue = WTF::move(m_renderQueue);
- if (!calledOnMainThread)
- m_renderQueueMutex.unlock();
-
- for (auto& function : renderQueue)
- function();
-}
-
-void CoordinatedGraphicsScene::purgeGLResources()
-{
- m_imageBackings.clear();
- m_releasedImageBackings.clear();
-#if USE(GRAPHICS_SURFACE)
- m_surfaceBackingStores.clear();
-#endif
- m_surfaces.clear();
-
- m_rootLayer = nullptr;
- m_rootLayerID = InvalidCoordinatedLayerID;
- m_layers.clear();
- m_fixedLayers.clear();
- m_textureMapper = nullptr;
- m_backingStores.clear();
- m_backingStoresWithPendingBuffers.clear();
-
- setActive(false);
-
- RefPtr<CoordinatedGraphicsScene> protector(this);
- dispatchOnMainThread([=] {
- protector->purgeBackingStores();
- });
-}
-
-void CoordinatedGraphicsScene::dispatchCommitScrollOffset(uint32_t layerID, const IntSize& offset)
-{
- m_client->commitScrollOffset(layerID, offset);
-}
-
-void CoordinatedGraphicsScene::commitScrollOffset(uint32_t layerID, const IntSize& offset)
-{
- RefPtr<CoordinatedGraphicsScene> protector(this);
- dispatchOnMainThread([=] {
- protector->dispatchCommitScrollOffset(layerID, offset);
- });
-}
-
-void CoordinatedGraphicsScene::purgeBackingStores()
-{
- if (m_client)
- m_client->purgeBackingStores();
-}
-
-void CoordinatedGraphicsScene::setLayerAnimationsIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
-{
- if (!state.animationsChanged)
- return;
-
- layer->setAnimations(state.animations);
-}
-
-void CoordinatedGraphicsScene::detach()
-{
- ASSERT(isMainThread());
- m_renderQueue.clear();
- m_client = 0;
-}
-
-void CoordinatedGraphicsScene::appendUpdate(std::function<void()> function)
-{
- if (!m_isActive)
- return;
-
- ASSERT(isMainThread());
- MutexLocker locker(m_renderQueueMutex);
- m_renderQueue.append(WTF::move(function));
-}
-
-void CoordinatedGraphicsScene::setActive(bool active)
-{
- if (m_isActive == active)
- return;
-
- // Have to clear render queue in both cases.
- // If there are some updates in queue during activation then those updates are from previous instance of paint node
- // and cannot be applied to the newly created instance.
- m_renderQueue.clear();
- m_isActive = active;
- if (m_isActive) {
- RefPtr<CoordinatedGraphicsScene> protector(this);
- dispatchOnMainThread([=] {
- protector->renderNextFrame();
- });
- }
-}
-
-TextureMapperLayer* CoordinatedGraphicsScene::findScrollableContentsLayerAt(const FloatPoint& point)
-{
- return rootLayer() ? rootLayer()->findScrollableContentsLayerAt(point) : 0;
-}
-
-} // namespace WebKit
-
-#endif // USE(COORDINATED_GRAPHICS)
</del></span></pre></div>
<a id="trunkSourceWebKit2UIProcessCoordinatedGraphicsCoordinatedGraphicsSceneh"></a>
<div class="delfile"><h4>Deleted: trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h (176945 => 176946)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h 2014-12-08 11:34:48 UTC (rev 176945)
+++ trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedGraphicsScene.h 2014-12-08 12:09:30 UTC (rev 176946)
</span><span class="lines">@@ -1,192 +0,0 @@
</span><del>-/*
- Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
- Copyright (C) 2013 Company 100, Inc.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Library General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public License
- along with this library; see the file COPYING.LIB. If not, write to
- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
-*/
-
-#ifndef CoordinatedGraphicsScene_h
-#define CoordinatedGraphicsScene_h
-
-#if USE(COORDINATED_GRAPHICS)
-#include <WebCore/CoordinatedGraphicsState.h>
-#include <WebCore/CoordinatedSurface.h>
-#include <WebCore/GraphicsContext.h>
-#include <WebCore/GraphicsLayer.h>
-#include <WebCore/GraphicsLayerAnimation.h>
-#include <WebCore/IntRect.h>
-#include <WebCore/IntSize.h>
-#include <WebCore/TextureMapper.h>
-#include <WebCore/TextureMapperBackingStore.h>
-#include <WebCore/TextureMapperFPSCounter.h>
-#include <WebCore/TextureMapperLayer.h>
-#include <WebCore/Timer.h>
-#include <functional>
-#include <wtf/HashSet.h>
-#include <wtf/ThreadingPrimitives.h>
-#include <wtf/Vector.h>
-
-#if USE(GRAPHICS_SURFACE)
-#include <WebCore/GraphicsSurface.h>
-#include <WebCore/TextureMapperSurfaceBackingStore.h>
-#endif
-
-namespace WebKit {
-
-class CoordinatedBackingStore;
-
-class CoordinatedGraphicsSceneClient {
-public:
- virtual ~CoordinatedGraphicsSceneClient() { }
- virtual void purgeBackingStores() = 0;
- virtual void renderNextFrame() = 0;
- virtual void updateViewport() = 0;
- virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) = 0;
-};
-
-class CoordinatedGraphicsScene : public ThreadSafeRefCounted<CoordinatedGraphicsScene>, public WebCore::TextureMapperLayer::ScrollingClient {
-public:
- explicit CoordinatedGraphicsScene(CoordinatedGraphicsSceneClient*);
- virtual ~CoordinatedGraphicsScene();
- void paintToCurrentGLContext(const WebCore::TransformationMatrix&, float, const WebCore::FloatRect&, const WebCore::Color& backgroundColor, bool drawsBackground, const WebCore::FloatPoint&, WebCore::TextureMapper::PaintFlags = 0);
- void paintToGraphicsContext(PlatformGraphicsContext*, const WebCore::Color& backgroundColor, bool drawsBackground);
- void detach();
- void appendUpdate(std::function<void()>);
-
- WebCore::TextureMapperLayer* findScrollableContentsLayerAt(const WebCore::FloatPoint&);
-
- virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
-
- // The painting thread must lock the main thread to use below two methods, because two methods access members that the main thread manages. See m_client.
- // Currently, QQuickWebPage::updatePaintNode() locks the main thread before calling both methods.
- void purgeGLResources();
-
- bool isActive() const { return m_isActive; }
- void setActive(bool);
-
- void commitSceneState(const WebCore::CoordinatedGraphicsState&);
-
- void setViewBackgroundColor(const WebCore::Color& color) { m_viewBackgroundColor = color; }
- WebCore::Color viewBackgroundColor() const { return m_viewBackgroundColor; }
-
-private:
- void setRootLayerID(WebCore::CoordinatedLayerID);
- void createLayers(const Vector<WebCore::CoordinatedLayerID>&);
- void deleteLayers(const Vector<WebCore::CoordinatedLayerID>&);
- void setLayerState(WebCore::CoordinatedLayerID, const WebCore::CoordinatedGraphicsLayerState&);
- void setLayerChildrenIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void updateTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void createTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void removeTilesIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void setLayerFiltersIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void setLayerAnimationsIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
-#if USE(GRAPHICS_SURFACE)
- void createPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void syncPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
- void destroyPlatformLayerIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
-#endif
- void setLayerRepaintCountIfNeeded(WebCore::TextureMapperLayer*, const WebCore::CoordinatedGraphicsLayerState&);
-
- void syncUpdateAtlases(const WebCore::CoordinatedGraphicsState&);
- void createUpdateAtlas(uint32_t atlasID, PassRefPtr<WebCore::CoordinatedSurface>);
- void removeUpdateAtlas(uint32_t atlasID);
-
- void syncImageBackings(const WebCore::CoordinatedGraphicsState&);
- void createImageBacking(WebCore::CoordinatedImageBackingID);
- void updateImageBacking(WebCore::CoordinatedImageBackingID, PassRefPtr<WebCore::CoordinatedSurface>);
- void clearImageBackingContents(WebCore::CoordinatedImageBackingID);
- void removeImageBacking(WebCore::CoordinatedImageBackingID);
-
- WebCore::TextureMapperLayer* layerByID(WebCore::CoordinatedLayerID id)
- {
- ASSERT(m_layers.contains(id));
- ASSERT(id != WebCore::InvalidCoordinatedLayerID);
- return m_layers.get(id);
- }
- WebCore::TextureMapperLayer* getLayerByIDIfExists(WebCore::CoordinatedLayerID);
- WebCore::TextureMapperLayer* rootLayer() { return m_rootLayer.get(); }
-
- void syncRemoteContent();
- void adjustPositionForFixedLayers(const WebCore::FloatPoint& contentPosition);
-
- void dispatchOnMainThread(std::function<void()>);
- void updateViewport();
- void renderNextFrame();
- void purgeBackingStores();
-
- void createLayer(WebCore::CoordinatedLayerID);
- void deleteLayer(WebCore::CoordinatedLayerID);
-
- void assignImageBackingToLayer(WebCore::TextureMapperLayer*, WebCore::CoordinatedImageBackingID);
- void removeReleasedImageBackingsIfNeeded();
- void ensureRootLayer();
- void commitPendingBackingStoreOperations();
-
- void prepareContentBackingStore(WebCore::TextureMapperLayer*);
- void createBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
- void removeBackingStoreIfNeeded(WebCore::TextureMapperLayer*);
- void resetBackingStoreSizeToLayerSize(WebCore::TextureMapperLayer*);
-
- void dispatchCommitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset);
-
- // Render queue can be accessed ony from main thread or updatePaintNode call stack!
- Vector<std::function<void()>> m_renderQueue;
- Mutex m_renderQueueMutex;
-
- std::unique_ptr<WebCore::TextureMapper> m_textureMapper;
-
- typedef HashMap<WebCore::CoordinatedImageBackingID, RefPtr<CoordinatedBackingStore>> ImageBackingMap;
- ImageBackingMap m_imageBackings;
- Vector<RefPtr<CoordinatedBackingStore>> m_releasedImageBackings;
-
- typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<CoordinatedBackingStore>> BackingStoreMap;
- BackingStoreMap m_backingStores;
-
- HashSet<RefPtr<CoordinatedBackingStore>> m_backingStoresWithPendingBuffers;
-
-#if USE(GRAPHICS_SURFACE)
- typedef HashMap<WebCore::TextureMapperLayer*, RefPtr<WebCore::TextureMapperSurfaceBackingStore>> SurfaceBackingStoreMap;
- SurfaceBackingStoreMap m_surfaceBackingStores;
-#endif
-
- typedef HashMap<uint32_t /* atlasID */, RefPtr<WebCore::CoordinatedSurface>> SurfaceMap;
- SurfaceMap m_surfaces;
-
- // Below two members are accessed by only the main thread. The painting thread must lock the main thread to access both members.
- CoordinatedGraphicsSceneClient* m_client;
- bool m_isActive;
-
- std::unique_ptr<WebCore::TextureMapperLayer> m_rootLayer;
-
- typedef HashMap<WebCore::CoordinatedLayerID, std::unique_ptr<WebCore::TextureMapperLayer>> LayerMap;
- LayerMap m_layers;
- typedef HashMap<WebCore::CoordinatedLayerID, WebCore::TextureMapperLayer*> LayerRawPtrMap;
- LayerRawPtrMap m_fixedLayers;
- WebCore::CoordinatedLayerID m_rootLayerID;
- WebCore::FloatPoint m_scrollPosition;
- WebCore::FloatPoint m_renderedContentsScrollPosition;
- WebCore::Color m_viewBackgroundColor;
-
- WebCore::TextureMapperFPSCounter m_fpsCounter;
-};
-
-} // namespace WebKit
-
-#endif // USE(COORDINATED_GRAPHICS)
-
-#endif // CoordinatedGraphicsScene_h
-
-
</del></span></pre>
</div>
</div>
</body>
</html>