← Back to branch summary

~ubuntu-branches/ubuntu/lucid/webkit/lucid-updates

« back to all changes in this revision

Viewing changes to WebCore/svg/graphics/SVGResourceFilter.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo Noronha Silva
  • Date: 2010-01-06 21:25:06 UTC
  • mfrom: (1.2.6 upstream) (4.3.7 sid)
  • Revision ID: james.westby@ubuntu.com-20100106212506-gd0czn4zrwf1j19l
http://bugs.debian.org/529271
http://bugs.debian.org/559420
* New upstream release
- adds basic Content-Encoding support, thanks to soup
  (Closes: #529271)
- fixes over-advertising content types as supported by
  the media player (Closes: #559420)
* debian/control:
- updated libsoup build requirement (>= 2.28.2)
* debian/libwebkit-1.0-2.symbols:
- updated with new symbols
* debian/copyright:
- updated information since 1.1.17
* Imported patch from https://bugs.webkit.org/show_bug.cgi?id=30623
- I am shipping this patch because I believe it is correct, it is the
  way to go, it fixes a race, and it needs testing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
WebCore/svg/graphics/SVGResourceFilter.cpp
32
32
#include "SVGFilter.h"
33
33
#include "SVGFilterBuilder.h"
34
34
#include "SVGFilterElement.h"
 
35
#include "SVGRenderSupport.h"
35
36
#include "SVGRenderTreeAsText.h"
36
37
#include "SVGFilterPrimitiveStandardAttributes.h"
37
38
 
52
53
    , m_savedContext(0)
53
54
    , m_sourceGraphicBuffer(0)
54
55
{
55
 
    m_filterBuilder.set(new SVGFilterBuilder());
 
56
    m_filterBuilder.set(new SVGFilterBuilder());    
56
57
}
57
58
 
58
59
SVGResourceFilter::~SVGResourceFilter()
59
60
{
60
61
}
61
62
 
62
 
static inline bool shouldProcessFilter(SVGResourceFilter* filter)
63
 
{
64
 
    return (!filter->scaleX() || !filter->scaleY() || !filter->filterBoundingBox().width()
65
 
            || !filter->filterBoundingBox().height());
 
63
FloatRect SVGResourceFilter::filterBoundingBox(const FloatRect& obb) const
 
64
{
 
65
    return m_ownerElement->filterBoundingBox(obb);
 
66
}
 
67
 
 
68
static inline bool shouldProcessFilter(SVGResourceFilter* filter, const FloatRect& filterRect)
 
69
{
 
70
    return (!filter->scaleX() || !filter->scaleY() || !filterRect.width() || !filterRect.height());
66
71
}
67
72
 
68
73
void SVGResourceFilter::addFilterEffect(SVGFilterPrimitiveStandardAttributes* effectAttributes, PassRefPtr<FilterEffect> effect)
86
91
    return matchesFilterSize;
87
92
}
88
93
 
89
 
void SVGResourceFilter::prepareFilter(GraphicsContext*& context, const RenderObject* object)
 
94
bool SVGResourceFilter::prepareFilter(GraphicsContext*& context, const RenderObject* object)
90
95
{
91
 
    FloatRect targetRect = object->objectBoundingBox();
92
 
    m_ownerElement->buildFilter(targetRect);
93
 
 
94
 
    if (shouldProcessFilter(this))
95
 
        return;
 
96
    m_ownerElement->buildFilter(object->objectBoundingBox());
 
97
    const SVGRenderBase* renderer = object->toSVGRenderBase();
 
98
    if (!renderer)
 
99
        return false;
 
100
 
 
101
    FloatRect paintRect = renderer->strokeBoundingBox();
 
102
    paintRect.unite(renderer->markerBoundingBox());
 
103
 
 
104
    if (shouldProcessFilter(this, m_filterBBox))
 
105
        return false;
96
106
 
97
107
    // clip sourceImage to filterRegion
98
 
    FloatRect clippedSourceRect = targetRect;
 
108
    FloatRect clippedSourceRect = paintRect;
99
109
    clippedSourceRect.intersect(m_filterBBox);
100
110
 
101
111
    // scale filter size to filterRes
110
120
    fitsInMaximumImageSize(tempSourceRect.size());
111
121
 
112
122
    // prepare Filters
113
 
    m_filter = SVGFilter::create(targetRect, m_filterBBox, m_effectBBoxMode);
 
123
    m_filter = SVGFilter::create(paintRect, m_filterBBox, m_effectBBoxMode);
114
124
    m_filter->setFilterResolution(FloatSize(m_scaleX, m_scaleY));
115
125
 
116
126
    FilterEffect* lastEffect = m_filterBuilder->lastEffect();
122
132
            m_filter->setFilterResolution(FloatSize(m_scaleX, m_scaleY));
123
133
            lastEffect->calculateEffectRect(m_filter.get());
124
134
        }
125
 
    }
 
135
    } else
 
136
        return false;
126
137
 
127
138
    clippedSourceRect.scale(m_scaleX, m_scaleY);
128
139
 
132
143
    OwnPtr<ImageBuffer> sourceGraphic(ImageBuffer::create(bufferRect.size(), LinearRGB));
133
144
    
134
145
    if (!sourceGraphic.get())
135
 
        return;
 
146
        return false;
136
147
 
137
148
    GraphicsContext* sourceGraphicContext = sourceGraphic->context();
 
149
    sourceGraphicContext->translate(-clippedSourceRect.x(), -clippedSourceRect.y());
138
150
    sourceGraphicContext->scale(FloatSize(m_scaleX, m_scaleY));
139
 
    sourceGraphicContext->translate(-targetRect.x(), -targetRect.y());
140
 
    sourceGraphicContext->clearRect(FloatRect(FloatPoint(), targetRect.size()));
 
151
    sourceGraphicContext->clearRect(FloatRect(FloatPoint(), paintRect.size()));
141
152
    m_sourceGraphicBuffer.set(sourceGraphic.release());
142
153
    m_savedContext = context;
143
154
 
144
155
    context = sourceGraphicContext;
 
156
    return true;
145
157
}
146
158
 
147
159
void SVGResourceFilter::applyFilter(GraphicsContext*& context, const RenderObject* object)
148
160
{
149
 
    if (shouldProcessFilter(this))
150
 
        return;
151
 
 
152
161
    if (!m_savedContext)
153
162
        return;
154
163
 
204
213
    return ts;
205
214
}
206
215
 
207
 
SVGResourceFilter* getFilterById(Document* document, const AtomicString& id)
 
216
SVGResourceFilter* getFilterById(Document* document, const AtomicString& id, const RenderObject* object)
208
217
{
209
 
    SVGResource* resource = getResourceById(document, id);
 
218
    SVGResource* resource = getResourceById(document, id, object);
210
219
    if (resource && resource->isFilter())
211
220
        return static_cast<SVGResourceFilter*>(resource);
212
221