[TexMap] Seperate BitmapTexture related classes implementations from TextureMapper
authoryoon@igalia.com <yoon@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 28 Mar 2015 03:15:07 +0000 (03:15 +0000)
committeryoon@igalia.com <yoon@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 28 Mar 2015 03:15:07 +0000 (03:15 +0000)
https://bugs.webkit.org/show_bug.cgi?id=142386

Reviewed by Žan Doberšek.

TextureMapper and TextureMapperGL are bloated and tightly coupled with
BitmapTexture. We should move these classes to seperated file of their own.
Also, this patch removes friend relationship from TextureMapperGL and  its
subsidiary classes.

The main purpose of this refactoring is to expose BitmapTexturePool to
renderers of platformlayers like Video and Canvas. By doing this, each
renderer can acquire textures from the global texture pool to paint
their contents directly.

Source/WebCore:

No new tests needed.

* PlatformEfl.cmake:
* PlatformGTK.cmake:
* platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
Include BitmapTextureGL and BitmapTexturePool explicitly

* platform/graphics/texmap/BitmapTexture.cpp: Added.
* platform/graphics/texmap/BitmapTexture.h: Added.
(WebCore::BitmapTexture::updateContents):
Exclude BitmapTexture class from TextureMapper

* platform/graphics/texmap/BitmapTextureGL.cpp: Added.
* platform/graphics/texmap/BitmapTextureGL.h: Added.
Exclude BitmapTextureGL class from TextureMapperGL
(WebCore::BitmapTextureGL::clipStack): Added.
Add the getter for clipStack for TextureMapperGL
(WebCore::BitmapTextureGL::Bind): Deleted.
(WebCore::BitmapTextureGL::BindAsSurface): Added.
Bind used TextureMapperGL's internal data directly to compute projection matrix as a friend class,
However, TextureMapperGL can compute projection matrix itself after binding job, so this
friend ship is not needed. Also, this patch renames Bind to BindAsSurface to remove ambiguity.

* platform/graphics/texmap/BitmapTextureImageBuffer.cpp: Added.
* platform/graphics/texmap/BitmapTextureImageBuffer.h: Added.
Exclude BitmapTextureImageBuffer class from TextureMapperImageBuffer

* platform/graphics/texmap/BitmapTexturePool.cpp: Added.
* platform/graphics/texmap/BitmapTexturePool.h: Added.
Exclude BitmapTexturePool class from TextureMapperGL
(WebCore::BitmapTexturePool::acquireTexture):
Modified to use passed GraphicsContext3D instead of TextureMapperGL to remove redundant coupling

* platform/graphics/texmap/TextureMapper.cpp:
* platform/graphics/texmap/TextureMapper.h:
Remove BitmapTexturePool and BitmapTexture from its implementation.

* platform/graphics/texmap/TextureMapperGL.cpp:
* platform/graphics/texmap/TextureMapperGL.h:
Remove BitmapTextureGL from its implementation.
(WebCore::TextureMapperGL::TextureMapperGL):
(WebCore::TextureMapperGL::clipStack):
(WebCore::TextureMapperGL::bindSurface):
(WebCore::TextureMapperGL::currentSurface):
Add a getter of the current surface for filtering operation in BitmapTextureGL.
It would be clear to move filtering operation from BitmapTextureGL to TextureMapperGL later.

(WebCore::TextureMapperGL::ClipStack):
Move inner class declaration to public.

* platform/graphics/texmap/TextureMapperImageBuffer.cpp:
* platform/graphics/texmap/TextureMapperImageBuffer.h:
Remove BitmapTextureImageBuffer from its implementation.

Source/WebKit2:

* Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp: Include BitmapTextureGL.h explicitly

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@182101 268f45cc-cd09-0410-ab3c-d52691b4dbfc

20 files changed:
Source/WebCore/ChangeLog
Source/WebCore/PlatformEfl.cmake
Source/WebCore/PlatformGTK.cmake
Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
Source/WebCore/platform/graphics/texmap/BitmapTexture.cpp [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTexture.h [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTextureGL.h [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.cpp [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.h [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTexturePool.cpp [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/BitmapTexturePool.h [new file with mode: 0644]
Source/WebCore/platform/graphics/texmap/TextureMapper.cpp
Source/WebCore/platform/graphics/texmap/TextureMapper.h
Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
Source/WebCore/platform/graphics/texmap/TextureMapperImageBuffer.cpp
Source/WebCore/platform/graphics/texmap/TextureMapperImageBuffer.h
Source/WebKit2/ChangeLog
Source/WebKit2/Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp

index cc22990..43434a4 100644 (file)
@@ -1,3 +1,74 @@
+2015-03-27  Gwang Yoon Hwang  <yoon@igalia.com>
+
+        [TexMap] Seperate BitmapTexture related classes implementations from TextureMapper
+        https://bugs.webkit.org/show_bug.cgi?id=142386
+
+        Reviewed by Žan Doberšek.
+
+        TextureMapper and TextureMapperGL are bloated and tightly coupled with
+        BitmapTexture. We should move these classes to seperated file of their own.
+        Also, this patch removes friend relationship from TextureMapperGL and  its
+        subsidiary classes.
+
+        The main purpose of this refactoring is to expose BitmapTexturePool to
+        renderers of platformlayers like Video and Canvas. By doing this, each
+        renderer can acquire textures from the global texture pool to paint
+        their contents directly.
+
+        No new tests needed.
+
+        * PlatformEfl.cmake:
+        * PlatformGTK.cmake:
+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
+        Include BitmapTextureGL and BitmapTexturePool explicitly
+
+        * platform/graphics/texmap/BitmapTexture.cpp: Added.
+        * platform/graphics/texmap/BitmapTexture.h: Added.
+        (WebCore::BitmapTexture::updateContents):
+        Exclude BitmapTexture class from TextureMapper
+
+        * platform/graphics/texmap/BitmapTextureGL.cpp: Added.
+        * platform/graphics/texmap/BitmapTextureGL.h: Added.
+        Exclude BitmapTextureGL class from TextureMapperGL
+        (WebCore::BitmapTextureGL::clipStack): Added.
+        Add the getter for clipStack for TextureMapperGL
+        (WebCore::BitmapTextureGL::Bind): Deleted.
+        (WebCore::BitmapTextureGL::BindAsSurface): Added.
+        Bind used TextureMapperGL's internal data directly to compute projection matrix as a friend class,
+        However, TextureMapperGL can compute projection matrix itself after binding job, so this
+        friend ship is not needed. Also, this patch renames Bind to BindAsSurface to remove ambiguity.
+
+        * platform/graphics/texmap/BitmapTextureImageBuffer.cpp: Added.
+        * platform/graphics/texmap/BitmapTextureImageBuffer.h: Added.
+        Exclude BitmapTextureImageBuffer class from TextureMapperImageBuffer
+
+        * platform/graphics/texmap/BitmapTexturePool.cpp: Added.
+        * platform/graphics/texmap/BitmapTexturePool.h: Added.
+        Exclude BitmapTexturePool class from TextureMapperGL
+        (WebCore::BitmapTexturePool::acquireTexture):
+        Modified to use passed GraphicsContext3D instead of TextureMapperGL to remove redundant coupling
+
+        * platform/graphics/texmap/TextureMapper.cpp:
+        * platform/graphics/texmap/TextureMapper.h:
+        Remove BitmapTexturePool and BitmapTexture from its implementation.
+
+        * platform/graphics/texmap/TextureMapperGL.cpp:
+        * platform/graphics/texmap/TextureMapperGL.h:
+        Remove BitmapTextureGL from its implementation.
+        (WebCore::TextureMapperGL::TextureMapperGL):
+        (WebCore::TextureMapperGL::clipStack):
+        (WebCore::TextureMapperGL::bindSurface):
+        (WebCore::TextureMapperGL::currentSurface):
+        Add a getter of the current surface for filtering operation in BitmapTextureGL.
+        It would be clear to move filtering operation from BitmapTextureGL to TextureMapperGL later.
+
+        (WebCore::TextureMapperGL::ClipStack):
+        Move inner class declaration to public.
+
+        * platform/graphics/texmap/TextureMapperImageBuffer.cpp:
+        * platform/graphics/texmap/TextureMapperImageBuffer.h:
+        Remove BitmapTextureImageBuffer from its implementation.
+
 2015-03-27  Tim Horton  <timothy_horton@apple.com>
 
         WebProcess started by editable WKWebView spends 15% of its initialization time loading DataDetectors
index 6351d30..f71eb60 100644 (file)
@@ -179,6 +179,10 @@ list(APPEND WebCore_SOURCES
 
     platform/graphics/surfaces/glx/X11Helper.cpp
 
+    platform/graphics/texmap/BitmapTexture.cpp
+    platform/graphics/texmap/BitmapTextureGL.cpp
+    platform/graphics/texmap/BitmapTextureImageBuffer.cpp
+    platform/graphics/texmap/BitmapTexturePool.cpp
     platform/graphics/texmap/GraphicsLayerTextureMapper.cpp
     platform/graphics/texmap/TextureMapperGL.cpp
     platform/graphics/texmap/TextureMapperShaderProgram.cpp
index b8ee863..3403dee 100644 (file)
@@ -382,8 +382,13 @@ if (ENABLE_TEXTURE_MAPPER)
         "${WEBCORE_DIR}/platform/graphics/texmap"
     )
     list(APPEND WebCore_SOURCES
+        platform/graphics/texmap/BitmapTexture.cpp
+        platform/graphics/texmap/BitmapTextureGL.cpp
+        platform/graphics/texmap/BitmapTextureImageBuffer.cpp
+        platform/graphics/texmap/BitmapTexturePool.cpp
         platform/graphics/texmap/GraphicsLayerTextureMapper.cpp
         platform/graphics/texmap/TextureMapperGL.cpp
+        platform/graphics/texmap/TextureMapperImageBuffer.cpp
         platform/graphics/texmap/TextureMapperShaderProgram.cpp
     )
 endif ()
index 1342a8e..fe21b75 100644 (file)
@@ -45,6 +45,8 @@
 #include <gst/video/gstvideometa.h>
 
 #if GST_CHECK_VERSION(1, 1, 0) && USE(TEXTURE_MAPPER_GL)
+#include "BitmapTextureGL.h"
+#include "BitmapTexturePool.h"
 #include "TextureMapperGL.h"
 #endif
 
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTexture.cpp b/Source/WebCore/platform/graphics/texmap/BitmapTexture.cpp
new file mode 100644 (file)
index 0000000..3454403
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "BitmapTexture.h"
+
+#include "GraphicsLayer.h"
+#include "ImageBuffer.h"
+#include "TextureMapper.h"
+
+namespace WebCore {
+
+void BitmapTexture::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
+{
+    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(targetRect.size());
+    GraphicsContext* context = imageBuffer->context();
+    context->setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
+    context->setTextDrawingMode(textureMapper->textDrawingMode());
+
+    IntRect sourceRect(targetRect);
+    sourceRect.setLocation(offset);
+    context->translate(-offset.x(), -offset.y());
+    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
+
+    RefPtr<Image> image = imageBuffer->copyImage(DontCopyBackingStore);
+
+    updateContents(image.get(), targetRect, IntPoint(), updateContentsFlag);
+}
+
+} // namespace
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTexture.h b/Source/WebCore/platform/graphics/texmap/BitmapTexture.h
new file mode 100644 (file)
index 0000000..6625f2f
--- /dev/null
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BitmapTexture_h
+#define BitmapTexture_h
+
+#if USE(OPENGL_ES_2)
+#define TEXMAP_OPENGL_ES_2
+#endif
+
+#include "IntPoint.h"
+#include "IntRect.h"
+#include "IntSize.h"
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
+
+namespace WebCore {
+
+class FilterOperations;
+class GraphicsLayer;
+class Image;
+class TextureMapper;
+
+// A 2D texture that can be the target of software or GL rendering.
+class BitmapTexture : public RefCounted<BitmapTexture> {
+public:
+    enum Flag {
+        NoFlag = 0,
+        SupportsAlpha = 0x01
+    };
+
+    enum UpdateContentsFlag {
+        UpdateCanModifyOriginalImageData,
+        UpdateCannotModifyOriginalImageData
+    };
+
+    typedef unsigned Flags;
+
+    BitmapTexture()
+        : m_flags(0)
+    {
+    }
+
+    virtual ~BitmapTexture() { }
+    virtual bool isBackedByOpenGL() const { return false; }
+
+    virtual IntSize size() const = 0;
+    virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
+    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
+    virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
+    virtual bool isValid() const = 0;
+    inline Flags flags() const { return m_flags; }
+
+    virtual int bpp() const { return 32; }
+    virtual bool canReuseWith(const IntSize& /* contentsSize */, Flags = 0) { return false; }
+    void reset(const IntSize& size, Flags flags = 0)
+    {
+        m_flags = flags;
+        m_contentSize = size;
+        didReset();
+    }
+    virtual void didReset() { }
+
+    inline IntSize contentSize() const { return m_contentSize; }
+    inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
+    inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
+
+    virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) { return this; }
+
+protected:
+    IntSize m_contentSize;
+
+private:
+    Flags m_flags;
+};
+
+}
+
+#endif // BitmapTexture_h
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp b/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp
new file mode 100644 (file)
index 0000000..975c38f
--- /dev/null
@@ -0,0 +1,379 @@
+/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ Copyright (C) 2012 Igalia S.L.
+ Copyright (C) 2012 Adobe Systems Incorporated
+
+ 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 "BitmapTextureGL.h"
+
+#include "Extensions3D.h"
+#include "FilterOperations.h"
+#include "GraphicsContext.h"
+#include "Image.h"
+#include "LengthFunctions.h"
+#include "NotImplemented.h"
+#include "TextureMapperShaderProgram.h"
+#include "Timer.h"
+#include <wtf/HashMap.h>
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefCounted.h>
+#include <wtf/TemporaryChange.h>
+
+#if USE(CAIRO)
+#include "CairoUtilities.h"
+#include "RefPtrCairo.h"
+#include <cairo.h>
+#include <wtf/text/CString.h>
+#endif
+
+#if !USE(TEXMAP_OPENGL_ES_2)
+// FIXME: Move to Extensions3D.h.
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#endif
+
+namespace WebCore {
+
+BitmapTextureGL* toBitmapTextureGL(BitmapTexture* texture)
+{
+    if (!texture || !texture->isBackedByOpenGL())
+        return 0;
+
+    return static_cast<BitmapTextureGL*>(texture);
+}
+
+BitmapTextureGL::BitmapTextureGL(PassRefPtr<GraphicsContext3D> context3D)
+    : m_id(0)
+    , m_fbo(0)
+    , m_rbo(0)
+    , m_depthBufferObject(0)
+    , m_shouldClear(true)
+    , m_context3D(context3D)
+{
+}
+
+bool BitmapTextureGL::canReuseWith(const IntSize& contentsSize, Flags)
+{
+    return contentsSize == m_textureSize;
+}
+
+#if OS(DARWIN)
+#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
+#else
+#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GraphicsContext3D::UNSIGNED_BYTE
+#endif
+
+static void swizzleBGRAToRGBA(uint32_t* data, const IntRect& rect, int stride = 0)
+{
+    stride = stride ? stride : rect.width();
+    for (int y = rect.y(); y < rect.maxY(); ++y) {
+        uint32_t* p = data + y * stride;
+        for (int x = rect.x(); x < rect.maxX(); ++x)
+            p[x] = ((p[x] << 16) & 0xff0000) | ((p[x] >> 16) & 0xff) | (p[x] & 0xff00ff00);
+    }
+}
+
+// If GL_EXT_texture_format_BGRA8888 is supported in the OpenGLES
+// internal and external formats need to be BGRA
+static bool driverSupportsExternalTextureBGRA(GraphicsContext3D* context)
+{
+    if (context->isGLES2Compliant()) {
+        static bool supportsExternalTextureBGRA = context->getExtensions()->supports("GL_EXT_texture_format_BGRA8888");
+        return supportsExternalTextureBGRA;
+    }
+
+    return true;
+}
+
+static bool driverSupportsSubImage(GraphicsContext3D* context)
+{
+    if (context->isGLES2Compliant()) {
+        static bool supportsSubImage = context->getExtensions()->supports("GL_EXT_unpack_subimage");
+        return supportsSubImage;
+    }
+
+    return true;
+}
+
+void BitmapTextureGL::didReset()
+{
+    if (!m_id)
+        m_id = m_context3D->createTexture();
+
+    m_shouldClear = true;
+    if (m_textureSize == contentSize())
+        return;
+
+
+    m_textureSize = contentSize();
+    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
+    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
+    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
+    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
+    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
+
+    Platform3DObject internalFormat = GraphicsContext3D::RGBA;
+    Platform3DObject externalFormat = GraphicsContext3D::BGRA;
+    if (m_context3D->isGLES2Compliant()) {
+        if (driverSupportsExternalTextureBGRA(m_context3D.get()))
+            internalFormat = GraphicsContext3D::BGRA;
+        else
+            externalFormat = GraphicsContext3D::RGBA;
+    }
+
+    m_context3D->texImage2DDirect(GraphicsContext3D::TEXTURE_2D, 0, internalFormat, m_textureSize.width(), m_textureSize.height(), 0, externalFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, 0);
+}
+
+void BitmapTextureGL::updateContentsNoSwizzle(const void* srcData, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, unsigned bytesPerPixel, Platform3DObject glFormat)
+{
+    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
+    // For ES drivers that don't support sub-images.
+    if (driverSupportsSubImage(m_context3D.get())) {
+        // Use the OpenGL sub-image extension, now that we know it's available.
+        m_context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, bytesPerLine / bytesPerPixel);
+        m_context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, sourceOffset.y());
+        m_context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, sourceOffset.x());
+    }
+
+    m_context3D->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, srcData);
+
+    // For ES drivers that don't support sub-images.
+    if (driverSupportsSubImage(m_context3D.get())) {
+        m_context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        m_context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+        m_context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+    }
+}
+
+void BitmapTextureGL::updateContents(const void* srcData, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag updateContentsFlag)
+{
+    Platform3DObject glFormat = GraphicsContext3D::RGBA;
+    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
+
+    const unsigned bytesPerPixel = 4;
+    char* data = reinterpret_cast<char*>(const_cast<void*>(srcData));
+    Vector<char> temporaryData;
+    IntPoint adjustedSourceOffset = sourceOffset;
+
+    // Texture upload requires subimage buffer if driver doesn't support subimage and we don't have full image upload.
+    bool requireSubImageBuffer = !driverSupportsSubImage(m_context3D.get())
+        && !(bytesPerLine == static_cast<int>(targetRect.width() * bytesPerPixel) && adjustedSourceOffset == IntPoint::zero());
+
+    // prepare temporaryData if necessary
+    if ((!driverSupportsExternalTextureBGRA(m_context3D.get()) && updateContentsFlag == UpdateCannotModifyOriginalImageData) || requireSubImageBuffer) {
+        temporaryData.resize(targetRect.width() * targetRect.height() * bytesPerPixel);
+        data = temporaryData.data();
+        const char* bits = static_cast<const char*>(srcData);
+        const char* src = bits + sourceOffset.y() * bytesPerLine + sourceOffset.x() * bytesPerPixel;
+        char* dst = data;
+        const int targetBytesPerLine = targetRect.width() * bytesPerPixel;
+        for (int y = 0; y < targetRect.height(); ++y) {
+            memcpy(dst, src, targetBytesPerLine);
+            src += bytesPerLine;
+            dst += targetBytesPerLine;
+        }
+
+        bytesPerLine = targetBytesPerLine;
+        adjustedSourceOffset = IntPoint(0, 0);
+    }
+
+    if (driverSupportsExternalTextureBGRA(m_context3D.get()))
+        glFormat = GraphicsContext3D::BGRA;
+    else
+        swizzleBGRAToRGBA(reinterpret_cast_ptr<uint32_t*>(data), IntRect(adjustedSourceOffset, targetRect.size()), bytesPerLine / bytesPerPixel);
+
+    updateContentsNoSwizzle(data, targetRect, adjustedSourceOffset, bytesPerLine, bytesPerPixel, glFormat);
+}
+
+void BitmapTextureGL::updateContents(Image* image, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
+{
+    if (!image)
+        return;
+    NativeImagePtr frameImage = image->nativeImageForCurrentFrame();
+    if (!frameImage)
+        return;
+
+    int bytesPerLine;
+    const char* imageData;
+
+#if USE(CAIRO)
+    cairo_surface_t* surface = frameImage.get();
+    imageData = reinterpret_cast<const char*>(cairo_image_surface_get_data(surface));
+    bytesPerLine = cairo_image_surface_get_stride(surface);
+#endif
+
+    updateContents(imageData, targetRect, offset, bytesPerLine, updateContentsFlag);
+}
+
+static unsigned getPassesRequiredForFilter(FilterOperation::OperationType type)
+{
+    switch (type) {
+    case FilterOperation::GRAYSCALE:
+    case FilterOperation::SEPIA:
+    case FilterOperation::SATURATE:
+    case FilterOperation::HUE_ROTATE:
+    case FilterOperation::INVERT:
+    case FilterOperation::BRIGHTNESS:
+    case FilterOperation::CONTRAST:
+    case FilterOperation::OPACITY:
+        return 1;
+    case FilterOperation::BLUR:
+    case FilterOperation::DROP_SHADOW:
+        // We use two-passes (vertical+horizontal) for blur and drop-shadow.
+        return 2;
+    default:
+        return 0;
+    }
+}
+
+PassRefPtr<BitmapTexture> BitmapTextureGL::applyFilters(TextureMapper* textureMapper, const FilterOperations& filters)
+{
+    if (filters.isEmpty())
+        return this;
+
+    TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);
+    RefPtr<BitmapTexture> previousSurface = texmapGL->currentSurface();
+    RefPtr<BitmapTexture> resultSurface = this;
+    RefPtr<BitmapTexture> intermediateSurface;
+    RefPtr<BitmapTexture> spareSurface;
+
+    m_filterInfo = FilterInfo();
+
+    for (size_t i = 0; i < filters.size(); ++i) {
+        RefPtr<FilterOperation> filter = filters.operations()[i];
+        ASSERT(filter);
+
+        int numPasses = getPassesRequiredForFilter(filter->type());
+        for (int j = 0; j < numPasses; ++j) {
+            bool last = (i == filters.size() - 1) && (j == numPasses - 1);
+            if (!last) {
+                if (!intermediateSurface)
+                    intermediateSurface = texmapGL->acquireTextureFromPool(contentSize());
+                texmapGL->bindSurface(intermediateSurface.get());
+            }
+
+            if (last) {
+                toBitmapTextureGL(resultSurface.get())->m_filterInfo = BitmapTextureGL::FilterInfo(filter, j, spareSurface);
+                break;
+            }
+
+            texmapGL->drawFiltered(*resultSurface.get(), spareSurface.get(), *filter, j);
+            if (!j && filter->type() == FilterOperation::DROP_SHADOW) {
+                spareSurface = resultSurface;
+                resultSurface.clear();
+            }
+            std::swap(resultSurface, intermediateSurface);
+        }
+    }
+
+    texmapGL->bindSurface(previousSurface.get());
+    return resultSurface;
+}
+
+void BitmapTextureGL::initializeStencil()
+{
+    if (m_rbo)
+        return;
+
+    m_rbo = m_context3D->createRenderbuffer();
+    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_rbo);
+#ifdef TEXMAP_OPENGL_ES_2
+    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX8, m_textureSize.width(), m_textureSize.height());
+#else
+    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_STENCIL, m_textureSize.width(), m_textureSize.height());
+#endif
+    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
+    m_context3D->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_rbo);
+    m_context3D->clearStencil(0);
+    m_context3D->clear(GraphicsContext3D::STENCIL_BUFFER_BIT);
+}
+
+void BitmapTextureGL::initializeDepthBuffer()
+{
+    if (m_depthBufferObject)
+        return;
+
+    m_depthBufferObject = m_context3D->createRenderbuffer();
+    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthBufferObject);
+    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, m_textureSize.width(), m_textureSize.height());
+    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
+    m_context3D->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthBufferObject);
+}
+
+void BitmapTextureGL::clearIfNeeded()
+{
+    if (!m_shouldClear)
+        return;
+
+    m_clipStack.reset(IntRect(IntPoint::zero(), m_textureSize), TextureMapperGL::ClipStack::DefaultYAxis);
+    m_clipStack.applyIfNeeded(m_context3D.get());
+    m_context3D->clearColor(0, 0, 0, 0);
+    m_context3D->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
+    m_shouldClear = false;
+}
+
+void BitmapTextureGL::createFboIfNeeded()
+{
+    if (m_fbo)
+        return;
+
+    m_fbo = m_context3D->createFramebuffer();
+    m_context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
+    m_context3D->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, id(), 0);
+    m_shouldClear = true;
+}
+
+void BitmapTextureGL::bindAsSurface(GraphicsContext3D* context3D)
+{
+    context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);
+    createFboIfNeeded();
+    context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
+    context3D->viewport(0, 0, m_textureSize.width(), m_textureSize.height());
+    clearIfNeeded();
+    m_clipStack.apply(m_context3D.get());
+}
+
+BitmapTextureGL::~BitmapTextureGL()
+{
+    if (m_id)
+        m_context3D->deleteTexture(m_id);
+
+    if (m_fbo)
+        m_context3D->deleteFramebuffer(m_fbo);
+
+    if (m_rbo)
+        m_context3D->deleteRenderbuffer(m_rbo);
+
+    if (m_depthBufferObject)
+        m_context3D->deleteRenderbuffer(m_depthBufferObject);
+}
+
+bool BitmapTextureGL::isValid() const
+{
+    return m_id;
+}
+
+IntSize BitmapTextureGL::size() const
+{
+    return m_textureSize;
+}
+
+}; // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.h b/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.h
new file mode 100644 (file)
index 0000000..7e0e42e
--- /dev/null
@@ -0,0 +1,95 @@
+/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ Copyright (C) 2014 Igalia S.L.
+
+ 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 BitmapTextureGL_h
+#define BitmapTextureGL_h
+
+#include "BitmapTexture.h"
+#include "FilterOperation.h"
+#include "GraphicsContext3D.h"
+#include "IntSize.h"
+#include "TextureMapperGL.h"
+
+namespace WebCore {
+
+class TextureMapper;
+class TextureMapperGL;
+class FilterOperation;
+
+class BitmapTextureGL : public BitmapTexture {
+public:
+    BitmapTextureGL(PassRefPtr<GraphicsContext3D>);
+
+    virtual IntSize size() const;
+    virtual bool isValid() const;
+    virtual bool canReuseWith(const IntSize& contentsSize, Flags = 0);
+    virtual void didReset();
+    void bindAsSurface(GraphicsContext3D*);
+    void initializeStencil();
+    void initializeDepthBuffer();
+    ~BitmapTextureGL();
+    virtual uint32_t id() const { return m_id; }
+    uint32_t textureTarget() const { return GraphicsContext3D::TEXTURE_2D; }
+    IntSize textureSize() const { return m_textureSize; }
+    void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
+    virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
+    void updateContentsNoSwizzle(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, unsigned bytesPerPixel = 4, Platform3DObject glFormat = GraphicsContext3D::RGBA);
+    virtual bool isBackedByOpenGL() const { return true; }
+
+    virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) override;
+    struct FilterInfo {
+        RefPtr<FilterOperation> filter;
+        unsigned pass;
+        RefPtr<BitmapTexture> contentTexture;
+
+        FilterInfo(PassRefPtr<FilterOperation> f = 0, unsigned p = 0, PassRefPtr<BitmapTexture> t = 0)
+            : filter(f)
+            , pass(p)
+            , contentTexture(t)
+            { }
+    };
+    const FilterInfo* filterInfo() const { return &m_filterInfo; }
+    TextureMapperGL::ClipStack& clipStack() { return m_clipStack; }
+
+private:
+
+    Platform3DObject m_id;
+    IntSize m_textureSize;
+    IntRect m_dirtyRect;
+    Platform3DObject m_fbo;
+    Platform3DObject m_rbo;
+    Platform3DObject m_depthBufferObject;
+    bool m_shouldClear;
+    TextureMapperGL::ClipStack m_clipStack;
+    RefPtr<GraphicsContext3D> m_context3D;
+
+    BitmapTextureGL();
+
+    void clearIfNeeded();
+    void createFboIfNeeded();
+
+    FilterInfo m_filterInfo;
+};
+
+BitmapTextureGL* toBitmapTextureGL(BitmapTexture*);
+
+}
+
+#endif // BitmapTextureGL_h
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.cpp b/Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.cpp
new file mode 100644 (file)
index 0000000..3641ac8
--- /dev/null
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "BitmapTextureImageBuffer.h"
+
+#include "GraphicsLayer.h"
+
+namespace WebCore {
+
+void BitmapTextureImageBuffer::updateContents(const void* data, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag)
+{
+#if PLATFORM(CAIRO)
+    RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create_for_data(static_cast<unsigned char*>(data()),
+        CAIRO_FORMAT_ARGB32, targetRect.width(), targetRect.height(), bytesPerLine));
+    m_image->context()->platformContext()->drawSurfaceToContext(surface.get(), targetRect,
+        IntRect(sourceOffset, targetRect.size()), m_image->context());
+#else
+    UNUSED_PARAM(data);
+    UNUSED_PARAM(targetRect);
+    UNUSED_PARAM(sourceOffset);
+    UNUSED_PARAM(bytesPerLine);
+#endif
+}
+
+void BitmapTextureImageBuffer::updateContents(TextureMapper*, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& sourceOffset, UpdateContentsFlag)
+{
+    GraphicsContext* context = m_image->context();
+
+    context->clearRect(targetRect);
+
+    IntRect sourceRect(targetRect);
+    sourceRect.setLocation(sourceOffset);
+    context->save();
+    context->clip(targetRect);
+    context->translate(targetRect.x() - sourceOffset.x(), targetRect.y() - sourceOffset.y());
+    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
+    context->restore();
+}
+
+void BitmapTextureImageBuffer::didReset()
+{
+    m_image = ImageBuffer::create(contentSize());
+}
+
+void BitmapTextureImageBuffer::updateContents(Image* image, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag)
+{
+    m_image->context()->drawImage(image, ColorSpaceDeviceRGB, targetRect, IntRect(offset, targetRect.size()), CompositeCopy);
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.h b/Source/WebCore/platform/graphics/texmap/BitmapTextureImageBuffer.h
new file mode 100644 (file)
index 0000000..648d2de
--- /dev/null
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BitmapTextureImageBuffer_h
+#define BitmapTextureImageBuffer_h
+
+#include "BitmapTexture.h"
+#include "ImageBuffer.h"
+#include "IntRect.h"
+#include "IntSize.h"
+
+namespace WebCore {
+
+class GraphicsContext;
+
+class BitmapTextureImageBuffer : public BitmapTexture {
+public:
+    static PassRefPtr<BitmapTexture> create() { return adoptRef(new BitmapTextureImageBuffer); }
+    virtual IntSize size() const { return m_image->internalSize(); }
+    virtual void didReset();
+    virtual bool isValid() const { return m_image.get(); }
+    inline GraphicsContext* graphicsContext() { return m_image ? m_image->context() : 0; }
+    virtual void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
+    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
+    virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
+    PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&);
+    ImageBuffer* image() const { return m_image.get(); }
+
+private:
+    BitmapTextureImageBuffer() { }
+    std::unique_ptr<ImageBuffer> m_image;
+};
+
+}
+
+#endif // BitmapTextureImageBuffer_h
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTexturePool.cpp b/Source/WebCore/platform/graphics/texmap/BitmapTexturePool.cpp
new file mode 100644 (file)
index 0000000..a444280
--- /dev/null
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2015 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "BitmapTexturePool.h"
+
+#if USE(TEXTURE_MAPPER_GL)
+#include "BitmapTextureGL.h"
+#include "GLContext.h"
+#else
+#include "BitmapTextureImageBuffer.h"
+#endif
+
+namespace WebCore {
+
+const double s_releaseUnusedSecondsTolerance = 3;
+const double s_releaseUnusedTexturesTimerInterval = 0.5;
+
+BitmapTexturePool::BitmapTexturePool()
+    : m_releaseUnusedTexturesTimer(*this, &BitmapTexturePool::releaseUnusedTexturesTimerFired)
+{
+}
+
+#if USE(TEXTURE_MAPPER_GL)
+BitmapTexturePool::BitmapTexturePool(PassRefPtr<GraphicsContext3D> context)
+    : m_context3D(context)
+    , m_releaseUnusedTexturesTimer(*this, &BitmapTexturePool::releaseUnusedTexturesTimerFired)
+{
+}
+#endif
+
+void BitmapTexturePool::scheduleReleaseUnusedTextures()
+{
+    if (m_releaseUnusedTexturesTimer.isActive())
+        m_releaseUnusedTexturesTimer.stop();
+
+    m_releaseUnusedTexturesTimer.startOneShot(s_releaseUnusedTexturesTimerInterval);
+}
+
+void BitmapTexturePool::releaseUnusedTexturesTimerFired()
+{
+    if (m_textures.isEmpty())
+        return;
+
+    // Delete entries, which have been unused in s_releaseUnusedSecondsTolerance.
+    std::sort(m_textures.begin(), m_textures.end(), BitmapTexturePoolEntry::compareTimeLastUsed);
+
+    double minUsedTime = monotonicallyIncreasingTime() - s_releaseUnusedSecondsTolerance;
+    for (size_t i = 0; i < m_textures.size(); ++i) {
+        if (m_textures[i].m_timeLastUsed < minUsedTime) {
+            m_textures.remove(i, m_textures.size() - i);
+            break;
+        }
+    }
+}
+
+PassRefPtr<BitmapTexture> BitmapTexturePool::acquireTexture(const IntSize& size)
+{
+    BitmapTexturePoolEntry* selectedEntry = 0;
+    for (auto& entry : m_textures) {
+        // If the surface has only one reference (the one in m_textures), we can safely reuse it.
+        if (entry.m_texture->refCount() > 1)
+            continue;
+
+        if (entry.m_texture->canReuseWith(size)) {
+            selectedEntry = &entry;
+            break;
+        }
+    }
+
+    if (!selectedEntry) {
+        m_textures.append(BitmapTexturePoolEntry(createTexture()));
+        selectedEntry = &m_textures.last();
+    }
+
+    scheduleReleaseUnusedTextures();
+    selectedEntry->markUsed();
+    return selectedEntry->m_texture;
+}
+
+PassRefPtr<BitmapTexture> BitmapTexturePool::createTexture()
+{
+#if USE(TEXTURE_MAPPER_GL)
+    BitmapTextureGL* texture = new BitmapTextureGL(m_context3D);
+    return adoptRef(texture);
+#else
+    return BitmapTextureImageBuffer::create();
+#endif
+}
+
+} // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/texmap/BitmapTexturePool.h b/Source/WebCore/platform/graphics/texmap/BitmapTexturePool.h
new file mode 100644 (file)
index 0000000..dc0cf66
--- /dev/null
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ * Copyright (C) 2014 Igalia S.L.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BitmapTexturePool_h
+#define BitmapTexturePool_h
+
+#if USE(OPENGL_ES_2)
+#define TEXMAP_OPENGL_ES_2
+#endif
+
+#include "BitmapTexture.h"
+#include "IntRect.h"
+#include "IntSize.h"
+#include "Timer.h"
+#include <wtf/CurrentTime.h>
+
+#if USE(TEXTURE_MAPPER_GL)
+#include "GraphicsContext3D.h"
+#endif
+
+namespace WebCore {
+
+class TextureMapper;
+
+struct BitmapTexturePoolEntry {
+    explicit BitmapTexturePoolEntry(PassRefPtr<BitmapTexture> texture)
+        : m_texture(texture)
+    { }
+    inline void markUsed() { m_timeLastUsed = monotonicallyIncreasingTime(); }
+    static bool compareTimeLastUsed(const BitmapTexturePoolEntry& a, const BitmapTexturePoolEntry& b)
+    {
+        return a.m_timeLastUsed - b.m_timeLastUsed > 0;
+    }
+
+    RefPtr<BitmapTexture> m_texture;
+    double m_timeLastUsed;
+};
+
+class BitmapTexturePool {
+    WTF_MAKE_NONCOPYABLE(BitmapTexturePool);
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    BitmapTexturePool();
+#if USE(TEXTURE_MAPPER_GL)
+    explicit BitmapTexturePool(PassRefPtr<GraphicsContext3D>);
+#endif
+
+    PassRefPtr<BitmapTexture> acquireTexture(const IntSize&);
+
+private:
+    void scheduleReleaseUnusedTextures();
+    void releaseUnusedTexturesTimerFired();
+    PassRefPtr<BitmapTexture> createTexture();
+
+#if USE(TEXTURE_MAPPER_GL)
+    RefPtr<GraphicsContext3D> m_context3D;
+#endif
+
+    Vector<BitmapTexturePoolEntry> m_textures;
+    Timer m_releaseUnusedTexturesTimer;
+};
+
+}
+
+#endif // BitmapTexturePool_h
index 4928608..033a61e 100644 (file)
@@ -20,6 +20,7 @@
 #include "config.h"
 #include "TextureMapper.h"
 
+#include "BitmapTexturePool.h"
 #include "FilterOperations.h"
 #include "GraphicsLayer.h"
 #include "TextureMapperImageBuffer.h"
 
 namespace WebCore {
 
-struct BitmapTexturePoolEntry {
-    explicit BitmapTexturePoolEntry(PassRefPtr<BitmapTexture> texture)
-        : m_texture(texture)
-    { }
-    inline void markUsed() { m_timeLastUsed = monotonicallyIncreasingTime(); }
-    static bool compareTimeLastUsed(const BitmapTexturePoolEntry& a, const BitmapTexturePoolEntry& b)
-    {
-        return a.m_timeLastUsed - b.m_timeLastUsed > 0;
-    }
-
-    RefPtr<BitmapTexture> m_texture;
-    double m_timeLastUsed;
-};
-
-class BitmapTexturePool {
-    WTF_MAKE_NONCOPYABLE(BitmapTexturePool);
-    WTF_MAKE_FAST_ALLOCATED;
-public:
-    BitmapTexturePool();
-
-    PassRefPtr<BitmapTexture> acquireTexture(const IntSize&, TextureMapper*);
-
-private:
-    void scheduleReleaseUnusedTextures();
-    void releaseUnusedTexturesTimerFired();
-
-    Vector<BitmapTexturePoolEntry> m_textures;
-    Timer m_releaseUnusedTexturesTimer;
-
-    static const double s_releaseUnusedSecondsTolerance;
-    static const double s_releaseUnusedTexturesTimerInterval;
-};
-
-const double BitmapTexturePool::s_releaseUnusedSecondsTolerance = 3;
-const double BitmapTexturePool::s_releaseUnusedTexturesTimerInterval = 0.5;
-
-BitmapTexturePool::BitmapTexturePool()
-    : m_releaseUnusedTexturesTimer(*this, &BitmapTexturePool::releaseUnusedTexturesTimerFired)
-{ }
-
-void BitmapTexturePool::scheduleReleaseUnusedTextures()
-{
-    if (m_releaseUnusedTexturesTimer.isActive())
-        m_releaseUnusedTexturesTimer.stop();
-
-    m_releaseUnusedTexturesTimer.startOneShot(s_releaseUnusedTexturesTimerInterval);
-}
-
-void BitmapTexturePool::releaseUnusedTexturesTimerFired()
-{
-    if (m_textures.isEmpty())
-        return;
-
-    // Delete entries, which have been unused in s_releaseUnusedSecondsTolerance.
-    std::sort(m_textures.begin(), m_textures.end(), BitmapTexturePoolEntry::compareTimeLastUsed);
-
-    double minUsedTime = monotonicallyIncreasingTime() - s_releaseUnusedSecondsTolerance;
-    for (size_t i = 0; i < m_textures.size(); ++i) {
-        if (m_textures[i].m_timeLastUsed < minUsedTime) {
-            m_textures.remove(i, m_textures.size() - i);
-            break;
-        }
-    }
-}
-
-PassRefPtr<BitmapTexture> BitmapTexturePool::acquireTexture(const IntSize& size, TextureMapper* textureMapper)
-{
-    BitmapTexturePoolEntry* selectedEntry = 0;
-    for (auto& entry : m_textures) {
-        // If the surface has only one reference (the one in m_textures), we can safely reuse it.
-        if (entry.m_texture->refCount() > 1)
-            continue;
-
-        if (entry.m_texture->canReuseWith(size)) {
-            selectedEntry = &entry;
-            break;
-        }
-    }
-
-    if (!selectedEntry) {
-        m_textures.append(BitmapTexturePoolEntry(textureMapper->createTexture()));
-        selectedEntry = &m_textures.last();
-    }
-
-    scheduleReleaseUnusedTextures();
-    selectedEntry->markUsed();
-    return selectedEntry->m_texture;
-}
-
 PassRefPtr<BitmapTexture> TextureMapper::acquireTextureFromPool(const IntSize& size, const BitmapTexture::Flags flags)
 {
-    RefPtr<BitmapTexture> selectedTexture = m_texturePool->acquireTexture(size, this);
+    RefPtr<BitmapTexture> selectedTexture = m_texturePool->acquireTexture(size);
     selectedTexture->reset(size, flags);
     return selectedTexture.release();
 }
@@ -137,7 +49,6 @@ TextureMapper::TextureMapper(AccelerationMode accelerationMode)
     : m_context(0)
     , m_interpolationQuality(InterpolationDefault)
     , m_textDrawingMode(TextModeFill)
-    , m_texturePool(std::make_unique<BitmapTexturePool>())
     , m_accelerationMode(accelerationMode)
     , m_isMaskMode(false)
     , m_wrapMode(StretchWrap)
@@ -146,23 +57,6 @@ TextureMapper::TextureMapper(AccelerationMode accelerationMode)
 TextureMapper::~TextureMapper()
 { }
 
-void BitmapTexture::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
-{
-    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(targetRect.size());
-    GraphicsContext* context = imageBuffer->context();
-    context->setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
-    context->setTextDrawingMode(textureMapper->textDrawingMode());
-
-    IntRect sourceRect(targetRect);
-    sourceRect.setLocation(offset);
-    context->translate(-offset.x(), -offset.y());
-    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
-
-    RefPtr<Image> image = imageBuffer->copyImage(DontCopyBackingStore);
-
-    updateContents(image.get(), targetRect, IntPoint(), updateContentsFlag);
-}
-
 } // namespace
 
 #endif
index 90d4e64..97e23e5 100644 (file)
 
 #if USE(TEXTURE_MAPPER)
 
-#if (PLATFORM(GTK) || PLATFORM(EFL)) && USE(OPENGL_ES_2)
+#if USE(OPENGL_ES_2)
 #define TEXMAP_OPENGL_ES_2
 #endif
 
+#include "BitmapTexture.h"
 #include "GraphicsContext.h"
 #include "IntRect.h"
 #include "IntSize.h"
@@ -43,64 +44,8 @@ class GraphicsLayer;
 class TextureMapper;
 class FilterOperations;
 
-// A 2D texture that can be the target of software or GL rendering.
-class BitmapTexture : public RefCounted<BitmapTexture> {
-public:
-    enum Flag {
-        NoFlag = 0,
-        SupportsAlpha = 0x01
-    };
-
-    enum UpdateContentsFlag {
-        UpdateCanModifyOriginalImageData,
-        UpdateCannotModifyOriginalImageData
-    };
-
-    typedef unsigned Flags;
-
-    BitmapTexture()
-        : m_flags(0)
-    {
-    }
-
-    virtual ~BitmapTexture() { }
-    virtual bool isBackedByOpenGL() const { return false; }
-
-    virtual IntSize size() const = 0;
-    virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
-    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
-    virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
-    virtual bool isValid() const = 0;
-    inline Flags flags() const { return m_flags; }
-
-    virtual int bpp() const { return 32; }
-    virtual bool canReuseWith(const IntSize& /* contentsSize */, Flags = 0) { return false; }
-    void reset(const IntSize& size, Flags flags = 0)
-    {
-        m_flags = flags;
-        m_contentSize = size;
-        didReset();
-    }
-    virtual void didReset() { }
-
-    inline IntSize contentSize() const { return m_contentSize; }
-    inline int numberOfBytes() const { return size().width() * size().height() * bpp() >> 3; }
-    inline bool isOpaque() const { return !(m_flags & SupportsAlpha); }
-
-    virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) { return this; }
-
-protected:
-    IntSize m_contentSize;
-
-private:
-    Flags m_flags;
-};
-
-// A "context" class used to encapsulate accelerated texture mapping functions: i.e. drawing a texture
-// onto the screen or into another texture with a specified transform, opacity and mask.
 class TextureMapper {
     WTF_MAKE_FAST_ALLOCATED;
-    friend class BitmapTexture;
 public:
     enum AccelerationMode { SoftwareMode, OpenGLMode };
     enum PaintFlag {
@@ -164,6 +109,7 @@ public:
 
 protected:
     GraphicsContext* m_context;
+    std::unique_ptr<BitmapTexturePool> m_texturePool;
 
     bool isInMaskMode() const { return m_isMaskMode; }
     WrapMode wrapMode() const { return m_wrapMode; }
@@ -180,7 +126,6 @@ private:
 #endif
     InterpolationQuality m_interpolationQuality;
     TextDrawingModeFlags m_textDrawingMode;
-    std::unique_ptr<BitmapTexturePool> m_texturePool;
     AccelerationMode m_accelerationMode;
     bool m_isMaskMode;
     TransformationMatrix m_patternTransform;
index 1154f4e..6aee23f 100644 (file)
@@ -22,6 +22,8 @@
 #include "config.h"
 #include "TextureMapperGL.h"
 
+#include "BitmapTextureGL.h"
+#include "BitmapTexturePool.h"
 #include "Extensions3D.h"
 #include "FilterOperations.h"
 #include "GraphicsContext.h"
@@ -238,25 +240,18 @@ void TextureMapperGLData::initializeStencil()
     didModifyStencil = true;
 }
 
-BitmapTextureGL* toBitmapTextureGL(BitmapTexture* texture)
-{
-    if (!texture || !texture->isBackedByOpenGL())
-        return 0;
-
-    return static_cast<BitmapTextureGL*>(texture);
-}
-
 TextureMapperGL::TextureMapperGL()
     : TextureMapper(OpenGLMode)
     , m_enableEdgeDistanceAntialiasing(false)
 {
     m_context3D = GraphicsContext3D::createForCurrentGLContext();
     m_data = new TextureMapperGLData(m_context3D.get());
+    m_texturePool = std::make_unique<BitmapTexturePool>(m_context3D);
 }
 
 TextureMapperGL::ClipStack& TextureMapperGL::clipStack()
 {
-    return data().currentSurface ? toBitmapTextureGL(data().currentSurface.get())->m_clipStack : m_clipStack;
+    return data().currentSurface ? toBitmapTextureGL(data().currentSurface.get())->clipStack() : m_clipStack;
 }
 
 void TextureMapperGL::beginPainting(PaintFlags flags)
@@ -391,27 +386,6 @@ static TextureMapperShaderProgram::Options optionsForFilterType(FilterOperation:
     }
 }
 
-static unsigned getPassesRequiredForFilter(FilterOperation::OperationType type)
-{
-    switch (type) {
-    case FilterOperation::GRAYSCALE:
-    case FilterOperation::SEPIA:
-    case FilterOperation::SATURATE:
-    case FilterOperation::HUE_ROTATE:
-    case FilterOperation::INVERT:
-    case FilterOperation::BRIGHTNESS:
-    case FilterOperation::CONTRAST:
-    case FilterOperation::OPACITY:
-        return 1;
-    case FilterOperation::BLUR:
-    case FilterOperation::DROP_SHADOW:
-        // We use two-passes (vertical+horizontal) for blur and drop-shadow.
-        return 2;
-    default:
-        return 0;
-    }
-}
-
 // Create a normal distribution of 21 values between -2 and 2.
 static const unsigned GaussianKernelHalfWidth = 11;
 static const float GaussianKernelStep = 0.2;
@@ -681,167 +655,6 @@ void TextureMapperGL::drawTexturedQuadWithProgram(TextureMapperShaderProgram* pr
     m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
 }
 
-BitmapTextureGL::BitmapTextureGL(TextureMapperGL* textureMapper)
-    : m_id(0)
-    , m_fbo(0)
-    , m_rbo(0)
-    , m_depthBufferObject(0)
-    , m_shouldClear(true)
-    , m_context3D(textureMapper->graphicsContext3D())
-{
-}
-
-bool BitmapTextureGL::canReuseWith(const IntSize& contentsSize, Flags)
-{
-    return contentsSize == m_textureSize;
-}
-
-#if OS(DARWIN)
-#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
-#else
-#define DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE GraphicsContext3D::UNSIGNED_BYTE
-#endif
-
-static void swizzleBGRAToRGBA(uint32_t* data, const IntRect& rect, int stride = 0)
-{
-    stride = stride ? stride : rect.width();
-    for (int y = rect.y(); y < rect.maxY(); ++y) {
-        uint32_t* p = data + y * stride;
-        for (int x = rect.x(); x < rect.maxX(); ++x)
-            p[x] = ((p[x] << 16) & 0xff0000) | ((p[x] >> 16) & 0xff) | (p[x] & 0xff00ff00);
-    }
-}
-
-// If GL_EXT_texture_format_BGRA8888 is supported in the OpenGLES
-// internal and external formats need to be BGRA
-static bool driverSupportsExternalTextureBGRA(GraphicsContext3D* context)
-{
-    if (context->isGLES2Compliant()) {
-        static bool supportsExternalTextureBGRA = context->getExtensions()->supports("GL_EXT_texture_format_BGRA8888");
-        return supportsExternalTextureBGRA;
-    }
-
-    return true;
-}
-
-static bool driverSupportsSubImage(GraphicsContext3D* context)
-{
-    if (context->isGLES2Compliant()) {
-        static bool supportsSubImage = context->getExtensions()->supports("GL_EXT_unpack_subimage");
-        return supportsSubImage;
-    }
-
-    return true;
-}
-
-void BitmapTextureGL::didReset()
-{
-    if (!m_id)
-        m_id = m_context3D->createTexture();
-
-    m_shouldClear = true;
-    if (m_textureSize == contentSize())
-        return;
-
-
-    m_textureSize = contentSize();
-    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
-    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
-    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
-    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
-    m_context3D->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
-
-    Platform3DObject internalFormat = GraphicsContext3D::RGBA;
-    Platform3DObject externalFormat = GraphicsContext3D::BGRA;
-    if (m_context3D->isGLES2Compliant()) {
-        if (driverSupportsExternalTextureBGRA(m_context3D.get()))
-            internalFormat = GraphicsContext3D::BGRA;
-        else
-            externalFormat = GraphicsContext3D::RGBA;
-    }
-
-    m_context3D->texImage2DDirect(GraphicsContext3D::TEXTURE_2D, 0, internalFormat, m_textureSize.width(), m_textureSize.height(), 0, externalFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, 0);
-}
-
-void BitmapTextureGL::updateContentsNoSwizzle(const void* srcData, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, unsigned bytesPerPixel, Platform3DObject glFormat)
-{
-    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
-    if (driverSupportsSubImage(m_context3D.get())) { // For ES drivers that don't support sub-images.
-        // Use the OpenGL sub-image extension, now that we know it's available.
-        m_context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, bytesPerLine / bytesPerPixel);
-        m_context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, sourceOffset.y());
-        m_context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, sourceOffset.x());
-    }
-
-    m_context3D->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(), glFormat, DEFAULT_TEXTURE_PIXEL_TRANSFER_TYPE, srcData);
-
-    if (driverSupportsSubImage(m_context3D.get())) { // For ES drivers that don't support sub-images.
-        m_context3D->pixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-        m_context3D->pixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-        m_context3D->pixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    }
-}
-
-void BitmapTextureGL::updateContents(const void* srcData, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag updateContentsFlag)
-{
-    Platform3DObject glFormat = GraphicsContext3D::RGBA;
-    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, m_id);
-
-    const unsigned bytesPerPixel = 4;
-    char* data = reinterpret_cast<char*>(const_cast<void*>(srcData));
-    Vector<char> temporaryData;
-    IntPoint adjustedSourceOffset = sourceOffset;
-
-    // Texture upload requires subimage buffer if driver doesn't support subimage and we don't have full image upload.
-    bool requireSubImageBuffer = !driverSupportsSubImage(m_context3D.get())
-        && !(bytesPerLine == static_cast<int>(targetRect.width() * bytesPerPixel) && adjustedSourceOffset == IntPoint::zero());
-
-    // prepare temporaryData if necessary
-    if ((!driverSupportsExternalTextureBGRA(m_context3D.get()) && updateContentsFlag == UpdateCannotModifyOriginalImageData) || requireSubImageBuffer) {
-        temporaryData.resize(targetRect.width() * targetRect.height() * bytesPerPixel);
-        data = temporaryData.data();
-        const char* bits = static_cast<const char*>(srcData);
-        const char* src = bits + sourceOffset.y() * bytesPerLine + sourceOffset.x() * bytesPerPixel;
-        char* dst = data;
-        const int targetBytesPerLine = targetRect.width() * bytesPerPixel;
-        for (int y = 0; y < targetRect.height(); ++y) {
-            memcpy(dst, src, targetBytesPerLine);
-            src += bytesPerLine;
-            dst += targetBytesPerLine;
-        }
-
-        bytesPerLine = targetBytesPerLine;
-        adjustedSourceOffset = IntPoint(0, 0);
-    }
-
-    if (driverSupportsExternalTextureBGRA(m_context3D.get()))
-        glFormat = GraphicsContext3D::BGRA;
-    else
-        swizzleBGRAToRGBA(reinterpret_cast_ptr<uint32_t*>(data), IntRect(adjustedSourceOffset, targetRect.size()), bytesPerLine / bytesPerPixel);
-
-    updateContentsNoSwizzle(data, targetRect, adjustedSourceOffset, bytesPerLine, bytesPerPixel, glFormat);
-}
-
-void BitmapTextureGL::updateContents(Image* image, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
-{
-    if (!image)
-        return;
-    NativeImagePtr frameImage = image->nativeImageForCurrentFrame();
-    if (!frameImage)
-        return;
-
-    int bytesPerLine;
-    const char* imageData;
-
-#if USE(CAIRO)
-    cairo_surface_t* surface = frameImage.get();
-    imageData = reinterpret_cast<const char*>(cairo_image_surface_get_data(surface));
-    bytesPerLine = cairo_image_surface_get_stride(surface);
-#endif
-
-    updateContents(imageData, targetRect, offset, bytesPerLine, updateContentsFlag);
-}
-
 void TextureMapperGL::drawFiltered(const BitmapTexture& sampler, const BitmapTexture* contentTexture, const FilterOperation& filter, int pass)
 {
     // For standard filters, we always draw the whole texture without transformations.
@@ -854,50 +667,6 @@ void TextureMapperGL::drawFiltered(const BitmapTexture& sampler, const BitmapTex
     drawTexturedQuadWithProgram(program.get(), static_cast<const BitmapTextureGL&>(sampler).id(), 0, IntSize(1, 1), targetRect, TransformationMatrix(), 1);
 }
 
-PassRefPtr<BitmapTexture> BitmapTextureGL::applyFilters(TextureMapper* textureMapper, const FilterOperations& filters)
-{
-    if (filters.isEmpty())
-        return this;
-
-    TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);
-    RefPtr<BitmapTexture> previousSurface = texmapGL->data().currentSurface;
-    RefPtr<BitmapTexture> resultSurface = this;
-    RefPtr<BitmapTexture> intermediateSurface;
-    RefPtr<BitmapTexture> spareSurface;
-
-    m_filterInfo = FilterInfo();
-
-    for (size_t i = 0; i < filters.size(); ++i) {
-        RefPtr<FilterOperation> filter = filters.operations()[i];
-        ASSERT(filter);
-
-        int numPasses = getPassesRequiredForFilter(filter->type());
-        for (int j = 0; j < numPasses; ++j) {
-            bool last = (i == filters.size() - 1) && (j == numPasses - 1);
-            if (!last) {
-                if (!intermediateSurface)
-                    intermediateSurface = texmapGL->acquireTextureFromPool(contentSize());
-                texmapGL->bindSurface(intermediateSurface.get());
-            }
-
-            if (last) {
-                toBitmapTextureGL(resultSurface.get())->m_filterInfo = BitmapTextureGL::FilterInfo(filter, j, spareSurface);
-                break;
-            }
-
-            texmapGL->drawFiltered(*resultSurface.get(), spareSurface.get(), *filter, j);
-            if (!j && filter->type() == FilterOperation::DROP_SHADOW) {
-                spareSurface = resultSurface;
-                resultSurface.clear();
-            }
-            std::swap(resultSurface, intermediateSurface);
-        }
-    }
-
-    texmapGL->bindSurface(previousSurface.get());
-    return resultSurface;
-}
-
 static inline TransformationMatrix createProjectionMatrix(const IntSize& size, bool mirrored)
 {
     const float nearValue = 9999999;
@@ -909,95 +678,6 @@ static inline TransformationMatrix createProjectionMatrix(const IntSize& size, b
                                 -1, mirrored ? -1 : 1, -(farValue + nearValue) / (farValue - nearValue), 1);
 }
 
-void BitmapTextureGL::initializeStencil()
-{
-    if (m_rbo)
-        return;
-
-    m_rbo = m_context3D->createRenderbuffer();
-    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_rbo);
-#ifdef TEXMAP_OPENGL_ES_2
-    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::STENCIL_INDEX8, m_textureSize.width(), m_textureSize.height());
-#else
-    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_STENCIL, m_textureSize.width(), m_textureSize.height());
-#endif
-    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
-    m_context3D->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::STENCIL_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_rbo);
-    m_context3D->clearStencil(0);
-    m_context3D->clear(GraphicsContext3D::STENCIL_BUFFER_BIT);
-}
-
-void BitmapTextureGL::initializeDepthBuffer()
-{
-    if (m_depthBufferObject)
-        return;
-
-    m_depthBufferObject = m_context3D->createRenderbuffer();
-    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthBufferObject);
-    m_context3D->renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, m_textureSize.width(), m_textureSize.height());
-    m_context3D->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
-    m_context3D->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthBufferObject);
-}
-
-void BitmapTextureGL::clearIfNeeded()
-{
-    if (!m_shouldClear)
-        return;
-
-    m_clipStack.reset(IntRect(IntPoint::zero(), m_textureSize), TextureMapperGL::ClipStack::DefaultYAxis);
-    m_clipStack.applyIfNeeded(m_context3D.get());
-    m_context3D->clearColor(0, 0, 0, 0);
-    m_context3D->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
-    m_shouldClear = false;
-}
-
-void BitmapTextureGL::createFboIfNeeded()
-{
-    if (m_fbo)
-        return;
-
-    m_fbo = m_context3D->createFramebuffer();
-    m_context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
-    m_context3D->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, id(), 0);
-    m_shouldClear = true;
-}
-
-void BitmapTextureGL::bind(TextureMapperGL* textureMapper)
-{
-    m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);
-    createFboIfNeeded();
-    m_context3D->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
-    m_context3D->viewport(0, 0, m_textureSize.width(), m_textureSize.height());
-    clearIfNeeded();
-    textureMapper->data().projectionMatrix = createProjectionMatrix(m_textureSize, true /* mirrored */);
-    m_clipStack.apply(m_context3D.get());
-}
-
-BitmapTextureGL::~BitmapTextureGL()
-{
-    if (m_id)
-        m_context3D->deleteTexture(m_id);
-
-    if (m_fbo)
-        m_context3D->deleteFramebuffer(m_fbo);
-
-    if (m_rbo)
-        m_context3D->deleteRenderbuffer(m_rbo);
-
-    if (m_depthBufferObject)
-        m_context3D->deleteRenderbuffer(m_depthBufferObject);
-}
-
-bool BitmapTextureGL::isValid() const
-{
-    return m_id;
-}
-
-IntSize BitmapTextureGL::size() const
-{
-    return m_textureSize;
-}
-
 TextureMapperGL::~TextureMapperGL()
 {
     delete m_data;
@@ -1020,10 +700,16 @@ void TextureMapperGL::bindSurface(BitmapTexture *surface)
         return;
     }
 
-    static_cast<BitmapTextureGL*>(surface)->bind(this);
+    static_cast<BitmapTextureGL*>(surface)->bindAsSurface(m_context3D.get());
+    data().projectionMatrix = createProjectionMatrix(surface->size(), true /* mirrored */);
     data().currentSurface = surface;
 }
 
+BitmapTexture* TextureMapperGL::currentSurface()
+{
+    return data().currentSurface.get();
+}
+
 bool TextureMapperGL::beginScissorClip(const TransformationMatrix& modelViewMatrix, const FloatRect& targetRect)
 {
     // 3D transforms are currently not supported in scissor clipping
@@ -1107,7 +793,7 @@ IntRect TextureMapperGL::clipBounds()
 
 PassRefPtr<BitmapTexture> TextureMapperGL::createTexture()
 {
-    BitmapTextureGL* texture = new BitmapTextureGL(this);
+    BitmapTextureGL* texture = new BitmapTextureGL(m_context3D);
     return adoptRef(texture);
 }
 
index 42407fb..bd9bf55 100644 (file)
@@ -1,5 +1,6 @@
 /*
  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+ Copyright (C) 2015 Igalia S.L.
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
@@ -38,40 +39,6 @@ class FilterOperation;
 // An OpenGL-ES2 implementation of TextureMapper.
 class TextureMapperGL : public TextureMapper {
 public:
-    TextureMapperGL();
-    virtual ~TextureMapperGL();
-
-    enum Flag {
-        ShouldBlend = 0x01,
-        ShouldFlipTexture = 0x02,
-        ShouldUseARBTextureRect = 0x04,
-        ShouldAntialias = 0x08
-    };
-
-    typedef int Flags;
-
-    // TextureMapper implementation
-    virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) override;
-    virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) override;
-    virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, unsigned exposedEdges) override;
-    virtual void drawTexture(Platform3DObject texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);
-    virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) override;
-
-    virtual void bindSurface(BitmapTexture* surface) override;
-    virtual void beginClip(const TransformationMatrix&, const FloatRect&) override;
-    virtual void beginPainting(PaintFlags = 0) override;
-    virtual void endPainting() override;
-    virtual void endClip() override;
-    virtual IntRect clipBounds() override;
-    virtual IntSize maxTextureSize() const override { return IntSize(2000, 2000); }
-    virtual PassRefPtr<BitmapTexture> createTexture() override;
-    inline GraphicsContext3D* graphicsContext3D() const { return m_context3D.get(); }
-
-    void drawFiltered(const BitmapTexture& sourceTexture, const BitmapTexture* contentTexture, const FilterOperation&, int pass);
-
-    void setEnableEdgeDistanceAntialiasing(bool enabled) { m_enableEdgeDistanceAntialiasing = enabled; }
-
-private:
     struct ClipState {
         IntRect scissorBox;
         int stencilIndex;
@@ -118,6 +85,41 @@ private:
         YAxisMode yAxisMode;
     };
 
+    TextureMapperGL();
+    virtual ~TextureMapperGL();
+
+    enum Flag {
+        ShouldBlend = 0x01,
+        ShouldFlipTexture = 0x02,
+        ShouldUseARBTextureRect = 0x04,
+        ShouldAntialias = 0x08
+    };
+
+    typedef int Flags;
+
+    // TextureMapper implementation
+    virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) override;
+    virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) override;
+    virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, unsigned exposedEdges) override;
+    virtual void drawTexture(Platform3DObject texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);
+    virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) override;
+
+    virtual void bindSurface(BitmapTexture* surface) override;
+    BitmapTexture* currentSurface();
+    virtual void beginClip(const TransformationMatrix&, const FloatRect&) override;
+    virtual void beginPainting(PaintFlags = 0) override;
+    virtual void endPainting() override;
+    virtual void endClip() override;
+    virtual IntRect clipBounds() override;
+    virtual IntSize maxTextureSize() const override { return IntSize(2000, 2000); }
+    virtual PassRefPtr<BitmapTexture> createTexture() override;
+    inline GraphicsContext3D* graphicsContext3D() const { return m_context3D.get(); }
+
+    void drawFiltered(const BitmapTexture& sourceTexture, const BitmapTexture* contentTexture, const FilterOperation&, int pass);
+
+    void setEnableEdgeDistanceAntialiasing(bool enabled) { m_enableEdgeDistanceAntialiasing = enabled; }
+
+private:
     void drawTexturedQuadWithProgram(TextureMapperShaderProgram*, uint32_t texture, Flags, const IntSize&, const FloatRect&, const TransformationMatrix& modelViewMatrix, float opacity);
     void draw(const FloatRect&, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram*, GC3Denum drawingMode, Flags);
 
@@ -132,68 +134,10 @@ private:
     TextureMapperGLData* m_data;
     ClipStack m_clipStack;
     bool m_enableEdgeDistanceAntialiasing;
-
-    friend class BitmapTextureGL;
-};
-
-class BitmapTextureGL : public BitmapTexture {
-public:
-    virtual IntSize size() const;
-    virtual bool isValid() const;
-    virtual bool canReuseWith(const IntSize& contentsSize, Flags = 0);
-    virtual void didReset();
-    void bind(TextureMapperGL*);
-    void initializeStencil();
-    void initializeDepthBuffer();
-    ~BitmapTextureGL();
-    virtual uint32_t id() const { return m_id; }
-    uint32_t textureTarget() const { return GraphicsContext3D::TEXTURE_2D; }
-    IntSize textureSize() const { return m_textureSize; }
-    void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
-    virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
-    virtual bool isBackedByOpenGL() const { return true; }
-
-    virtual PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&) override;
-    struct FilterInfo {
-        RefPtr<FilterOperation> filter;
-        unsigned pass;
-        RefPtr<BitmapTexture> contentTexture;
-
-        FilterInfo(PassRefPtr<FilterOperation> f = 0, unsigned p = 0, PassRefPtr<BitmapTexture> t = 0)
-            : filter(f)
-            , pass(p)
-            , contentTexture(t)
-            { }
-    };
-    const FilterInfo* filterInfo() const { return &m_filterInfo; }
-
-private:
-    void updateContentsNoSwizzle(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, unsigned bytesPerPixel = 4, Platform3DObject glFormat = GraphicsContext3D::RGBA);
-
-    Platform3DObject m_id;
-    IntSize m_textureSize;
-    IntRect m_dirtyRect;
-    Platform3DObject m_fbo;
-    Platform3DObject m_rbo;
-    Platform3DObject m_depthBufferObject;
-    bool m_shouldClear;
-    TextureMapperGL::ClipStack m_clipStack;
-    RefPtr<GraphicsContext3D> m_context3D;
-
-    explicit BitmapTextureGL(TextureMapperGL*);
-    BitmapTextureGL();
-
-    void clearIfNeeded();
-    void createFboIfNeeded();
-
-    FilterInfo m_filterInfo;
-
-    friend class TextureMapperGL;
 };
 
-BitmapTextureGL* toBitmapTextureGL(BitmapTexture*);
+} // namespace WebCore
 
-}
-#endif
+#endif // USE(TEXTURE_MAPPER)
 
-#endif
+#endif // TextureMapperGL_h
index 3beeb9f..6663269 100644 (file)
@@ -20,6 +20,7 @@
 #include "config.h"
 #include "TextureMapperImageBuffer.h"
 
+#include "BitmapTexturePool.h"
 #include "GraphicsLayer.h"
 #include "NotImplemented.h"
 
@@ -28,46 +29,10 @@ namespace WebCore {
 
 static const int s_maximumAllowedImageBufferDimension = 4096;
 
-void BitmapTextureImageBuffer::updateContents(const void* data, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag)
+TextureMapperImageBuffer::TextureMapperImageBuffer()
+    : TextureMapper(SoftwareMode)
 {
-#if PLATFORM(CAIRO)
-    RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create_for_data(static_cast<unsigned char*>(data()),
-                                                                                   CAIRO_FORMAT_ARGB32,
-                                                                                   targetRect.width(), targetRect.height(),
-                                                                                   bytesPerLine));
-    m_image->context()->platformContext()->drawSurfaceToContext(surface.get(), targetRect,
-                                                                IntRect(sourceOffset, targetRect.size()), m_image->context());
-#else
-    UNUSED_PARAM(data);
-    UNUSED_PARAM(targetRect);
-    UNUSED_PARAM(sourceOffset);
-    UNUSED_PARAM(bytesPerLine);
-#endif
-}
-
-void BitmapTextureImageBuffer::updateContents(TextureMapper*, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& sourceOffset, UpdateContentsFlag)
-{
-    GraphicsContext* context = m_image->context();
-
-    context->clearRect(targetRect);
-
-    IntRect sourceRect(targetRect);
-    sourceRect.setLocation(sourceOffset);
-    context->save();
-    context->clip(targetRect);
-    context->translate(targetRect.x() - sourceOffset.x(), targetRect.y() - sourceOffset.y());
-    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
-    context->restore();
-}
-
-void BitmapTextureImageBuffer::didReset()
-{
-    m_image = ImageBuffer::create(contentSize());
-}
-
-void BitmapTextureImageBuffer::updateContents(Image* image, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag)
-{
-    m_image->context()->drawImage(image, ColorSpaceDeviceRGB, targetRect, IntRect(offset, targetRect.size()), CompositeCopy);
+    m_texturePool = std::make_unique<BitmapTexturePool>();
 }
 
 IntSize TextureMapperImageBuffer::maxTextureSize() const
@@ -109,7 +74,7 @@ void TextureMapperImageBuffer::drawTexture(const BitmapTexture& texture, const F
         return;
 
     const BitmapTextureImageBuffer& textureImageBuffer = static_cast<const BitmapTextureImageBuffer&>(texture);
-    ImageBuffer* image = textureImageBuffer.m_image.get();
+    ImageBuffer* image = textureImageBuffer.image();
     context->save();
     context->setCompositeOperation(isInMaskMode() ? CompositeDestinationIn : CompositeSourceOver);
     context->setAlpha(opacity);
index 0177ddb..dd17193 100644 (file)
 #ifndef TextureMapperImageBuffer_h
 #define TextureMapperImageBuffer_h
 
+#include "BitmapTextureImageBuffer.h"
 #include "ImageBuffer.h"
 #include "TextureMapper.h"
 
 #if USE(TEXTURE_MAPPER)
 namespace WebCore {
 
-class BitmapTextureImageBuffer : public BitmapTexture {
-    friend class TextureMapperImageBuffer;
-public:
-    static PassRefPtr<BitmapTexture> create() { return adoptRef(new BitmapTextureImageBuffer); }
-    virtual IntSize size() const { return m_image->internalSize(); }
-    virtual void didReset();
-    virtual bool isValid() const { return m_image.get(); }
-    inline GraphicsContext* graphicsContext() { return m_image ? m_image->context() : 0; }
-    virtual void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
-    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
-    virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
-    PassRefPtr<BitmapTexture> applyFilters(TextureMapper*, const FilterOperations&);
-
-private:
-    BitmapTextureImageBuffer() { }
-    std::unique_ptr<ImageBuffer> m_image;
-};
-
-
 class TextureMapperImageBuffer : public TextureMapper {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    TextureMapperImageBuffer()
-        : TextureMapper(SoftwareMode)
-    { }
+    TextureMapperImageBuffer();
 
     // TextureMapper implementation
     virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) override;
index 9f8b73c..fa22d48 100644 (file)
@@ -1,3 +1,22 @@
+2015-03-27  Gwang Yoon Hwang  <yoon@igalia.com>
+
+        [TexMap] Seperate BitmapTexture related classes implementations from TextureMapper
+        https://bugs.webkit.org/show_bug.cgi?id=142386
+
+        Reviewed by Žan Doberšek.
+
+        TextureMapper and TextureMapperGL are bloated and tightly coupled with
+        BitmapTexture. We should move these classes to seperated file of their own.
+        Also, this patch removes friend relationship from TextureMapperGL and  its
+        subsidiary classes.
+
+        The main purpose of this refactoring is to expose BitmapTexturePool to
+        renderers of platformlayers like Video and Canvas. By doing this, each
+        renderer can acquire textures from the global texture pool to paint
+        their contents directly.
+
+        * Shared/CoordinatedGraphics/WebCoordinatedSurface.cpp: Include BitmapTextureGL.h explicitly
+
 2015-03-27  Anders Carlsson  <andersca@apple.com>
 
         Use a typedef for the WKPluginLoadClientPolicy enum
index f4647cb..7feaeea 100644 (file)
@@ -28,6 +28,7 @@
 #include <WebCore/GraphicsSurfaceToken.h>
 
 #if USE(TEXTURE_MAPPER)
+#include "BitmapTextureGL.h"
 #include "TextureMapperGL.h"
 #endif