Changeset 117864 in webkit


Ignore:
Timestamp:
May 21, 2012 6:10:06 PM (12 years ago)
Author:
jamesr@google.com
Message:

[chromium] Port chromium compositor to use WebFilterOperation(s)
​https://bugs.webkit.org/show_bug.cgi?id=87046

Reviewed by Adrienne Walker.

Source/Platform:

This changes WebFilterOperation / WebFilterOperations from being simple wrappers over WebCore types to being
standalone. WebFilterOperation is a plain old data struct with some convenience constuctors and type
assertions. Each WebFilterOperation contains a type tag and the parameters needed for each filter.
WebFilterOperations represents an ordered list of WebFilterOperation instances and can be copied around as
needed. It also exposes a few convenience functions about how the filters will modify pixels.

  • Platform.gypi:
  • chromium/public/WebFilterOperation.h:

(WebFilterOperation):
(WebKit::WebFilterOperation::type):
(WebKit::WebFilterOperation::amount):
(WebKit::WebFilterOperation::dropShadowOffset):
(WebKit::WebFilterOperation::dropShadowColor):
(WebKit::WebFilterOperation::createGrayscaleFilter):
(WebKit::WebFilterOperation::createSepiaFilter):
(WebKit::WebFilterOperation::createSaturateFilter):
(WebKit::WebFilterOperation::createHueRotateFilter):
(WebKit::WebFilterOperation::createInvertFilter):
(WebKit::WebFilterOperation::createBrightnessFilter):
(WebKit::WebFilterOperation::createContrastFilter):
(WebKit::WebFilterOperation::createOpacityFilter):
(WebKit::WebFilterOperation::createBlurFilter):
(WebKit::WebFilterOperation::createDropShadowFilter):
(WebKit::WebFilterOperation::equals):
(WebKit::WebFilterOperation::WebFilterOperation):
(WebKit::operator==):
(WebKit::operator!=):

  • chromium/public/WebFilterOperations.h:

(WebKit):
(WebKit::WebFilterOperations::WebFilterOperations):
(WebKit::WebFilterOperations::operator=):
(WebFilterOperations):
(WebKit::operator==):
(WebKit::operator!=):

  • chromium/src/WebFilterOperations.cpp: Added.

(WebKit):
(WebFilterOperationsPrivate):
(WebKit::WebFilterOperations::initialize):
(WebKit::WebFilterOperations::destroy):
(WebKit::WebFilterOperations::assign):
(WebKit::WebFilterOperations::equals):
(WebKit::WebFilterOperations::append):
(WebKit::WebFilterOperations::clear):
(WebKit::WebFilterOperations::isEmpty):
(WebKit::spreadForStdDeviation):
(WebKit::WebFilterOperations::getOutsets):
(WebKit::WebFilterOperations::hasFilterThatMovesPixels):
(WebKit::WebFilterOperations::hasFilterThatAffectsOpacity):
(WebKit::WebFilterOperations::size):
(WebKit::WebFilterOperations::at):

Source/WebCore:

This converts all compositor implementation logic to use WebFilterOperation(s) directly instead of the WebCore
types. GraphicsLayerChromium bridges between a WebCore::FilterOperations to WebFilterOperations, doing the
necessary type conversions and checking for filters that our compositor implementation supports. This cleans up
the chromium compositor's dependencies and removes any thread constraints from WebCore::FilterOperation /
WebCore::FilterOperations.

Covered by existing layout tests and unit tests in FilterOperationsTest.cpp

  • WebCore.gyp/WebCore.gyp:
  • WebCore.gypi:
  • platform/chromium/support/WebFilterOperations.cpp: Moved to Source/Platform/chromium/src/
  • platform/graphics/chromium/GraphicsLayerChromium.cpp:

(WebCore::copyWebCoreFilterOperationsToWebFilterOperations):
(WebCore):
(WebCore::GraphicsLayerChromium::setFilters):
(WebCore::GraphicsLayerChromium::setBackgroundFilters):
(WebCore::GraphicsLayerChromium::updateTransform):
(WebCore::GraphicsLayerChromium::updateChildrenTransform):

  • platform/graphics/chromium/GraphicsLayerChromium.h:

(GraphicsLayerChromium):

  • platform/graphics/chromium/LayerChromium.cpp:

(WebCore::LayerChromium::setFilters):
(WebCore::LayerChromium::setBackgroundFilters):
(WebCore::LayerChromium::pushPropertiesTo):

  • platform/graphics/chromium/LayerChromium.h:

(LayerChromium):
(WebCore::LayerChromium::filters):
(WebCore::LayerChromium::backgroundFilters):

  • platform/graphics/chromium/RenderSurfaceChromium.h:

(WebCore::RenderSurfaceChromium::setFilters):
(WebCore::RenderSurfaceChromium::filters):
(WebCore::RenderSurfaceChromium::setBackgroundFilters):
(WebCore::RenderSurfaceChromium::backgroundFilters):
(RenderSurfaceChromium):

  • platform/graphics/chromium/cc/CCDamageTracker.cpp:

(WebCore::expandDamageRectWithFilters):
(WebCore::expandDamageRectInsideRectWithFilters):
(WebCore::CCDamageTracker::updateDamageTrackingState):

  • platform/graphics/chromium/cc/CCDamageTracker.h:

(WebKit):
(WebCore):
(CCDamageTracker):

  • platform/graphics/chromium/cc/CCLayerImpl.cpp:

(WebCore::CCLayerImpl::setFilters):
(WebCore::CCLayerImpl::setBackgroundFilters):

  • platform/graphics/chromium/cc/CCLayerImpl.h:

(CCLayerImpl):
(WebCore::CCLayerImpl::filters):
(WebCore::CCLayerImpl::backgroundFilters):

  • platform/graphics/chromium/cc/CCRenderSurface.cpp:

(WebCore::CCRenderSurface::applyFilters):

  • platform/graphics/chromium/cc/CCRenderSurface.h:

(WebCore::CCRenderSurface::setFilters):
(WebCore::CCRenderSurface::filters):
(CCRenderSurface):
(WebCore::CCRenderSurface::setBackgroundFilters):
(WebCore::CCRenderSurface::backgroundFilters):

  • platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp:

(WebCore::CCRenderSurfaceFilters::apply):

  • platform/graphics/chromium/cc/CCRenderSurfaceFilters.h:

(WebKit):
(CCRenderSurfaceFilters):

  • testing/Internals.cpp:

(WebCore::Internals::setBackgroundBlurOnNode):

Source/WebKit/chromium:

  • WebKit.gypi:
  • src/AssertMatchingEnums.cpp:
  • src/WebLayer.cpp:

(WebKit::WebLayer::setFilters):
(WebKit::WebLayer::setBackgroundFilters):

  • tests/CCDamageTrackerTest.cpp:

(WebKitTests::TEST_F):

  • tests/CCLayerImplTest.cpp:

(WebCore::TEST):

  • tests/CCLayerTreeHostTest.cpp:

(WTF::CCLayerTreeHostTestLayerOcclusionWithFilters::beginTest):

  • tests/CCOcclusionTrackerTest.cpp:

(WebKitTests::CCOcclusionTrackerTest::createSurface):
(WebKitTests::CCOcclusionTrackerTest::createDrawingSurface):
(WebKitTests::CCOcclusionTrackerTestFilters::runMyTest):
(WebKitTests::CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter::runMyTest):
(WebKitTests::CCOcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice::runMyTest):
(WebKitTests::CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip::runMyTest):
(WebKitTests::CCOcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter::runMyTest):
(WebKitTests::CCOcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded::runMyTest):
(WebKitTests::CCOcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded::runMyTest):

  • tests/FilterOperationsTest.cpp: Added. Tests the existing behavior of WebCore::FilterOperations::getOutsets and makes sure WebFilterOperations' behavior matches.

(WebKit):
(WebKit::TEST):

  • tests/GraphicsLayerChromiumTest.cpp:
Location:
trunk/Source
Files:
2 added
1 deleted
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/Platform/ChangeLog

    r117538 r117864  
     12012-05-21  James Robinson  <jamesr@chromium.org>
     2
     3        [chromium] Port chromium compositor to use WebFilterOperation(s)
     4        https://bugs.webkit.org/show_bug.cgi?id=87046
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This changes WebFilterOperation / WebFilterOperations from being simple wrappers over WebCore types to being
     9        standalone. WebFilterOperation is a plain old data struct with some convenience constuctors and type
     10        assertions. Each WebFilterOperation contains a type tag and the parameters needed for each filter.
     11        WebFilterOperations represents an ordered list of WebFilterOperation instances and can be copied around as
     12        needed. It also exposes a few convenience functions about how the filters will modify pixels.
     13
     14        * Platform.gypi:
     15        * chromium/public/WebFilterOperation.h:
     16        (WebFilterOperation):
     17        (WebKit::WebFilterOperation::type):
     18        (WebKit::WebFilterOperation::amount):
     19        (WebKit::WebFilterOperation::dropShadowOffset):
     20        (WebKit::WebFilterOperation::dropShadowColor):
     21        (WebKit::WebFilterOperation::createGrayscaleFilter):
     22        (WebKit::WebFilterOperation::createSepiaFilter):
     23        (WebKit::WebFilterOperation::createSaturateFilter):
     24        (WebKit::WebFilterOperation::createHueRotateFilter):
     25        (WebKit::WebFilterOperation::createInvertFilter):
     26        (WebKit::WebFilterOperation::createBrightnessFilter):
     27        (WebKit::WebFilterOperation::createContrastFilter):
     28        (WebKit::WebFilterOperation::createOpacityFilter):
     29        (WebKit::WebFilterOperation::createBlurFilter):
     30        (WebKit::WebFilterOperation::createDropShadowFilter):
     31        (WebKit::WebFilterOperation::equals):
     32        (WebKit::WebFilterOperation::WebFilterOperation):
     33        (WebKit::operator==):
     34        (WebKit::operator!=):
     35        * chromium/public/WebFilterOperations.h:
     36        (WebKit):
     37        (WebKit::WebFilterOperations::WebFilterOperations):
     38        (WebKit::WebFilterOperations::operator=):
     39        (WebFilterOperations):
     40        (WebKit::operator==):
     41        (WebKit::operator!=):
     42        * chromium/src/WebFilterOperations.cpp: Added.
     43        (WebKit):
     44        (WebFilterOperationsPrivate):
     45        (WebKit::WebFilterOperations::initialize):
     46        (WebKit::WebFilterOperations::destroy):
     47        (WebKit::WebFilterOperations::assign):
     48        (WebKit::WebFilterOperations::equals):
     49        (WebKit::WebFilterOperations::append):
     50        (WebKit::WebFilterOperations::clear):
     51        (WebKit::WebFilterOperations::isEmpty):
     52        (WebKit::spreadForStdDeviation):
     53        (WebKit::WebFilterOperations::getOutsets):
     54        (WebKit::WebFilterOperations::hasFilterThatMovesPixels):
     55        (WebKit::WebFilterOperations::hasFilterThatAffectsOpacity):
     56        (WebKit::WebFilterOperations::size):
     57        (WebKit::WebFilterOperations::at):
     58
    1592012-05-17  Mark Pilgrim  <pilgrim@chromium.org>
    260

  • trunk/Source/Platform/Platform.gypi

    r117538 r117864  
    111111            'chromium/src/Platform.cpp',
    112112            'chromium/src/WebCString.cpp',
     113            'chromium/src/WebFilterOperations.cpp',
    113114            'chromium/src/WebFloatQuad.cpp',
    114115            'chromium/src/WebPrerenderingSupport.cpp',

  • trunk/Source/Platform/chromium/public/WebFilterOperation.h

    r115930 r117864  
    3030
    3131#include "WebColor.h"
    32 
    33 #if WEBKIT_IMPLEMENTATION
    34 #include <wtf/PassRefPtr.h>
    35 #endif
     32#include "WebPoint.h"
    3633
    3734namespace WebKit {
    3835
    39 struct WebFilterOperation {
     36class WebFilterOperation {
     37public:
    4038    enum FilterType {
    41         FilterTypeBasicColorMatrix,
    42         FilterTypeBasicComponentTransfer,
     39        FilterTypeGrayscale,
     40        FilterTypeSepia,
     41        FilterTypeSaturate,
     42        FilterTypeHueRotate,
     43        FilterTypeInvert,
     44        FilterTypeBrightness,
     45        FilterTypeContrast,
     46        FilterTypeOpacity,
    4347        FilterTypeBlur,
    44         FilterTypeDropShadow
     48        FilterTypeDropShadow,
    4549    };
    4650
    47     FilterType type;
     51    FilterType type() const { return m_type; }
    4852
    49 protected:
    50     WebFilterOperation(FilterType type)
    51         : type(type)
    52     { }
     53    float amount() const
     54    {
     55        return m_amount;
     56    }
     57    WebPoint dropShadowOffset() const
     58    {
     59        WEBKIT_ASSERT(m_type == FilterTypeDropShadow);
     60        return WebPoint(m_dropShadowOffset);
     61    }
     62    WebColor dropShadowColor() const
     63    {
     64        WEBKIT_ASSERT(m_type == FilterTypeDropShadow);
     65        return m_dropShadowColor;
     66    }
     67
     68#define WEBKIT_HAS_NEW_WEBFILTEROPERATION_API 1
     69    static WebFilterOperation createGrayscaleFilter(float amount) { return WebFilterOperation(FilterTypeGrayscale, amount); }
     70    static WebFilterOperation createSepiaFilter(float amount) { return WebFilterOperation(FilterTypeSepia, amount); }
     71    static WebFilterOperation createSaturateFilter(float amount) { return WebFilterOperation(FilterTypeSaturate, amount); }
     72    static WebFilterOperation createHueRotateFilter(float amount) { return WebFilterOperation(FilterTypeHueRotate, amount); }
     73    static WebFilterOperation createInvertFilter(float amount) { return WebFilterOperation(FilterTypeInvert, amount); }
     74    static WebFilterOperation createBrightnessFilter(float amount) { return WebFilterOperation(FilterTypeBrightness, amount); }
     75    static WebFilterOperation createContrastFilter(float amount) { return WebFilterOperation(FilterTypeContrast, amount); }
     76    static WebFilterOperation createOpacityFilter(float amount) { return WebFilterOperation(FilterTypeOpacity, amount); }
     77    static WebFilterOperation createBlurFilter(float amount) { return WebFilterOperation(FilterTypeBlur, amount); }
     78    static WebFilterOperation createDropShadowFilter(WebPoint offset, float stdDeviation, WebColor color) { return WebFilterOperation(FilterTypeDropShadow, offset, stdDeviation, color); }
     79
     80    bool equals(const WebFilterOperation& other) const
     81    {
     82        return m_amount == other.m_amount
     83            && m_dropShadowOffset == other.m_dropShadowOffset
     84            && m_dropShadowColor == other.m_dropShadowColor;
     85    }
     86
     87private:
     88    FilterType m_type;
     89
     90    float m_amount;
     91    WebPoint m_dropShadowOffset;
     92    WebColor m_dropShadowColor;
     93
     94    WebFilterOperation(FilterType type, float amount)
     95    {
     96        WEBKIT_ASSERT(type != FilterTypeDropShadow);
     97        m_type = type;
     98        m_amount = amount;
     99        m_dropShadowColor = 0;
     100    }
     101
     102    WebFilterOperation(FilterType type, WebPoint offset, float stdDeviation, WebColor color)
     103    {
     104        WEBKIT_ASSERT(type == FilterTypeDropShadow);
     105        m_type = type;
     106        m_amount = stdDeviation;
     107        m_dropShadowOffset = offset;
     108        m_dropShadowColor = color;
     109    }
    53110};
    54111
    55 struct WebBasicColorMatrixFilterOperation : public WebFilterOperation {
    56     enum BasicColorMatrixFilterType {
    57         BasicColorMatrixFilterTypeGrayscale = 1,
    58         BasicColorMatrixFilterTypeSepia = 2,
    59         BasicColorMatrixFilterTypeSaturate = 3,
    60         BasicColorMatrixFilterTypeHueRotate = 4
    61     };
     112inline bool operator==(const WebFilterOperation& a, const WebFilterOperation& b)
     113{
     114    return a.equals(b);
     115}
    62116
    63     WebBasicColorMatrixFilterOperation(BasicColorMatrixFilterType type, float amount)
    64         : WebFilterOperation(FilterTypeBasicColorMatrix)
    65         , subtype(type)
    66         , amount(amount)
    67     { }
    68 
    69     BasicColorMatrixFilterType subtype;
    70     float amount;
    71 };
    72 
    73 struct WebBasicComponentTransferFilterOperation : public WebFilterOperation {
    74     enum BasicComponentTransferFilterType {
    75         BasicComponentTransferFilterTypeInvert = 5,
    76         BasicComponentTransferFilterTypeBrightness = 7,
    77         BasicComponentTransferFilterTypeContrast = 8
    78         // Opacity is missing because this is more expensive than just setting opacity on the layer,
    79         // and opacity is not allowed for background filters.
    80     };
    81 
    82     WebBasicComponentTransferFilterOperation(BasicComponentTransferFilterType type, float amount)
    83         : WebFilterOperation(FilterTypeBasicComponentTransfer)
    84         , subtype(type)
    85         , amount(amount)
    86     { }
    87 
    88     BasicComponentTransferFilterType subtype;
    89     float amount;
    90 };
    91 
    92 struct WebBlurFilterOperation : public WebFilterOperation {
    93     explicit WebBlurFilterOperation(int pixelRadius)
    94         : WebFilterOperation(FilterTypeBlur)
    95         , pixelRadius(pixelRadius)
    96     { }
    97 
    98     int pixelRadius;
    99 };
    100 
    101 struct WebDropShadowFilterOperation : public WebFilterOperation {
    102     WebDropShadowFilterOperation(int x, int y, int stdDeviation, WebColor color)
    103         : WebFilterOperation(FilterTypeDropShadow)
    104         , x(x)
    105         , y(y)
    106         , stdDeviation(stdDeviation)
    107         , color(color)
    108     { }
    109 
    110     int x;
    111     int y;
    112     int stdDeviation;
    113     WebColor color;
    114 };
     117inline bool operator!=(const WebFilterOperation& a, const WebFilterOperation& b)
     118{
     119    return !(a == b);
     120}
    115121
    116122}

  • trunk/Source/Platform/chromium/public/WebFilterOperations.h

    r117362 r117864  
    2828
    2929#include "WebCommon.h"
     30#include "WebFilterOperation.h"
    3031#include "WebPrivateOwnPtr.h"
    3132
    32 namespace WebCore {
    33 class FilterOperations;
     33namespace WebKit {
     34
     35class WebFilterOperationsPrivate;
     36
     37// An ordered list of filter operations.
     38class WebFilterOperations {
     39public:
     40    WebFilterOperations() { initialize(); }
     41    WebFilterOperations& operator=(const WebFilterOperations& other)
     42    {
     43        assign(other);
     44        return *this;
     45    }
     46    ~WebFilterOperations() { destroy(); }
     47
     48    WEBKIT_EXPORT void assign(const WebFilterOperations&);
     49    WEBKIT_EXPORT bool equals(const WebFilterOperations&) const;
     50
     51    WEBKIT_EXPORT void append(const WebFilterOperation&);
     52
     53    // Removes all filter operations.
     54    WEBKIT_EXPORT void clear();
     55    WEBKIT_EXPORT bool isEmpty() const;
     56
     57    WEBKIT_EXPORT void getOutsets(int& top, int& right, int& bottom, int& left) const;
     58    WEBKIT_EXPORT bool hasFilterThatMovesPixels() const;
     59    WEBKIT_EXPORT bool hasFilterThatAffectsOpacity() const;
     60
     61    WEBKIT_EXPORT size_t size() const;
     62    WEBKIT_EXPORT WebFilterOperation at(size_t) const;
     63
     64private:
     65    WEBKIT_EXPORT void initialize();
     66    WEBKIT_EXPORT void destroy();
     67
     68    WebPrivateOwnPtr<WebFilterOperationsPrivate> m_private;
     69};
     70
     71inline bool operator==(const WebFilterOperations& a, const WebFilterOperations& b)
     72{
     73    return a.equals(b);
    3474}
    3575
    36 namespace WebKit {
    37 struct WebFilterOperation;
    38 
    39 // An ordered set of filter operations.
    40 class WebFilterOperations {
    41 public:
    42     WebFilterOperations() { reset(); }
    43     ~WebFilterOperations() { destroy(); }
    44 
    45     WEBKIT_EXPORT void reset();
    46     WEBKIT_EXPORT void append(const WebFilterOperation&);
    47 
    48 #if WEBKIT_IMPLEMENTATION
    49     const WebCore::FilterOperations& toFilterOperations() const;
    50 #endif
    51 
    52 private:
    53     WEBKIT_EXPORT void destroy();
    54 
    55     WebPrivateOwnPtr<WebCore::FilterOperations> m_private;
    56 };
     76inline bool operator!=(const WebFilterOperations& a, const WebFilterOperations& b)
     77{
     78    return !(a == b);
     79}
    5780
    5881}

  • trunk/Source/WebCore/ChangeLog

    r117859 r117864  
     12012-05-21  James Robinson  <jamesr@chromium.org>
     2
     3        [chromium] Port chromium compositor to use WebFilterOperation(s)
     4        https://bugs.webkit.org/show_bug.cgi?id=87046
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This converts all compositor implementation logic to use WebFilterOperation(s) directly instead of the WebCore
     9        types. GraphicsLayerChromium bridges between a WebCore::FilterOperations to WebFilterOperations, doing the
     10        necessary type conversions and checking for filters that our compositor implementation supports. This cleans up
     11        the chromium compositor's dependencies and removes any thread constraints from WebCore::FilterOperation /
     12        WebCore::FilterOperations.
     13
     14        Covered by existing layout tests and unit tests in FilterOperationsTest.cpp
     15
     16        * WebCore.gyp/WebCore.gyp:
     17        * WebCore.gypi:
     18        * platform/chromium/support/WebFilterOperations.cpp: Moved to Source/Platform/chromium/src/
     19        * platform/graphics/chromium/GraphicsLayerChromium.cpp:
     20        (WebCore::copyWebCoreFilterOperationsToWebFilterOperations):
     21        (WebCore):
     22        (WebCore::GraphicsLayerChromium::setFilters):
     23        (WebCore::GraphicsLayerChromium::setBackgroundFilters):
     24        (WebCore::GraphicsLayerChromium::updateTransform):
     25        (WebCore::GraphicsLayerChromium::updateChildrenTransform):
     26        * platform/graphics/chromium/GraphicsLayerChromium.h:
     27        (GraphicsLayerChromium):
     28        * platform/graphics/chromium/LayerChromium.cpp:
     29        (WebCore::LayerChromium::setFilters):
     30        (WebCore::LayerChromium::setBackgroundFilters):
     31        (WebCore::LayerChromium::pushPropertiesTo):
     32        * platform/graphics/chromium/LayerChromium.h:
     33        (LayerChromium):
     34        (WebCore::LayerChromium::filters):
     35        (WebCore::LayerChromium::backgroundFilters):
     36        * platform/graphics/chromium/RenderSurfaceChromium.h:
     37        (WebCore::RenderSurfaceChromium::setFilters):
     38        (WebCore::RenderSurfaceChromium::filters):
     39        (WebCore::RenderSurfaceChromium::setBackgroundFilters):
     40        (WebCore::RenderSurfaceChromium::backgroundFilters):
     41        (RenderSurfaceChromium):
     42        * platform/graphics/chromium/cc/CCDamageTracker.cpp:
     43        (WebCore::expandDamageRectWithFilters):
     44        (WebCore::expandDamageRectInsideRectWithFilters):
     45        (WebCore::CCDamageTracker::updateDamageTrackingState):
     46        * platform/graphics/chromium/cc/CCDamageTracker.h:
     47        (WebKit):
     48        (WebCore):
     49        (CCDamageTracker):
     50        * platform/graphics/chromium/cc/CCLayerImpl.cpp:
     51        (WebCore::CCLayerImpl::setFilters):
     52        (WebCore::CCLayerImpl::setBackgroundFilters):
     53        * platform/graphics/chromium/cc/CCLayerImpl.h:
     54        (CCLayerImpl):
     55        (WebCore::CCLayerImpl::filters):
     56        (WebCore::CCLayerImpl::backgroundFilters):
     57        * platform/graphics/chromium/cc/CCRenderSurface.cpp:
     58        (WebCore::CCRenderSurface::applyFilters):
     59        * platform/graphics/chromium/cc/CCRenderSurface.h:
     60        (WebCore::CCRenderSurface::setFilters):
     61        (WebCore::CCRenderSurface::filters):
     62        (CCRenderSurface):
     63        (WebCore::CCRenderSurface::setBackgroundFilters):
     64        (WebCore::CCRenderSurface::backgroundFilters):
     65        * platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp:
     66        (WebCore::CCRenderSurfaceFilters::apply):
     67        * platform/graphics/chromium/cc/CCRenderSurfaceFilters.h:
     68        (WebKit):
     69        (CCRenderSurfaceFilters):
     70        * testing/Internals.cpp:
     71        (WebCore::Internals::setBackgroundBlurOnNode):
     72
    1732012-05-15  Gavin Barraclough  <barraclough@apple.com>
    274

  • trunk/Source/WebCore/WebCore.gyp/WebCore.gyp

    r117524 r117864  
    12051205        '../../JavaScriptCore/JavaScriptCore.gyp/JavaScriptCore.gyp:yarr',
    12061206        '../../WTF/WTF.gyp/WTF.gyp:wtf',
     1207        '../../Platform/Platform.gyp/Platform.gyp:webkit_platform',
    12071208        '<(chromium_src_dir)/build/temp_gyp/googleurl.gyp:googleurl',
    12081209        '<(chromium_src_dir)/skia/skia.gyp:skia',
    … …  
    12231224        '../../JavaScriptCore/JavaScriptCore.gyp/JavaScriptCore.gyp:yarr',
    12241225        '../../WTF/WTF.gyp/WTF.gyp:wtf',
     1226        '../../Platform/Platform.gyp/Platform.gyp:webkit_platform',
    12251227        '<(chromium_src_dir)/build/temp_gyp/googleurl.gyp:googleurl',
    12261228        '<(chromium_src_dir)/skia/skia.gyp:skia',
    … …  
    14671469      'dependencies': [
    14681470        'webcore_prerequisites',
    1469         '../../Platform/Platform.gyp/Platform.gyp:webkit_platform',
    14701471      ],
    14711472      'defines': [
    … …  
    20312032        '../testing',
    20322033        '../testing/v8',
     2034        '../../Platform/chromium',
    20332035      ],
    20342036      'sources': [

  • trunk/Source/WebCore/WebCore.gypi

    r117832 r117864  
    82998299            'platform/chromium/support/WebHTTPBody.cpp',
    83008300            'platform/chromium/support/WebHTTPLoadInfo.cpp',
    8301             'platform/chromium/support/WebFilterOperations.cpp',
    83028301            'platform/chromium/support/WebICECandidateDescriptor.cpp',
    83038302            'platform/chromium/support/WebICEOptions.cpp',

  • trunk/Source/WebCore/platform/graphics/chromium/ContentLayerChromium.h

    r116142 r117864  
    4040namespace WebCore {
    4141
    42 class LayerTilerChromium;
     42class GraphicsContext;
     43class IntRect;
    4344class LayerTextureUpdater;
    4445
    4546class ContentLayerDelegate {
    4647public:
     48    virtual void paintContents(GraphicsContext&, const IntRect& clip) = 0;
     49
     50protected:
    4751    virtual ~ContentLayerDelegate() { }
    48     virtual void paintContents(GraphicsContext&, const IntRect& clip) = 0;
    4952};
    5053

  • trunk/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp

    r117469 r117864  
    5959#include "SystemTime.h"
    6060
     61#include <public/WebFilterOperation.h>
     62#include <public/WebFilterOperations.h>
    6163#include <public/WebFloatPoint.h>
    6264#include <public/WebFloatRect.h>
    … …  
    6870
    6971using namespace std;
    70 
    71 using WebKit::WebContentLayer;
    72 using WebKit::WebLayer;
     72using namespace WebKit;
    7373
    7474namespace WebCore {
    … …  
    297297}
    298298
     299static bool copyWebCoreFilterOperationsToWebFilterOperations(const FilterOperations& filters, WebFilterOperations& webFilters)
     300{
     301    for (size_t i = 0; i < filters.size(); ++i) {
     302        const FilterOperation& op = *filters.at(i);
     303        switch (op.getOperationType()) {
     304        case FilterOperation::REFERENCE:
     305            return false; // Not supported.
     306        case FilterOperation::GRAYSCALE:
     307        case FilterOperation::SEPIA:
     308        case FilterOperation::SATURATE:
     309        case FilterOperation::HUE_ROTATE: {
     310            float amount = static_cast<const BasicColorMatrixFilterOperation*>(&op)->amount();
     311            switch (op.getOperationType()) {
     312            case FilterOperation::GRAYSCALE:
     313                webFilters.append(WebFilterOperation::createGrayscaleFilter(amount));
     314                break;
     315            case FilterOperation::SEPIA:
     316                webFilters.append(WebFilterOperation::createSepiaFilter(amount));
     317                break;
     318            case FilterOperation::SATURATE:
     319                webFilters.append(WebFilterOperation::createSaturateFilter(amount));
     320                break;
     321            case FilterOperation::HUE_ROTATE:
     322                webFilters.append(WebFilterOperation::createHueRotateFilter(amount));
     323                break;
     324            default:
     325                ASSERT_NOT_REACHED();
     326            }
     327            break;
     328        }
     329        case FilterOperation::INVERT:
     330        case FilterOperation::OPACITY:
     331        case FilterOperation::BRIGHTNESS:
     332        case FilterOperation::CONTRAST: {
     333            float amount = static_cast<const BasicComponentTransferFilterOperation*>(&op)->amount();
     334            switch (op.getOperationType()) {
     335            case FilterOperation::INVERT:
     336                webFilters.append(WebFilterOperation::createInvertFilter(amount));
     337                break;
     338            case FilterOperation::OPACITY:
     339                webFilters.append(WebFilterOperation::createOpacityFilter(amount));
     340                break;
     341            case FilterOperation::BRIGHTNESS:
     342                webFilters.append(WebFilterOperation::createBrightnessFilter(amount));
     343                break;
     344            case FilterOperation::CONTRAST:
     345                webFilters.append(WebFilterOperation::createContrastFilter(amount));
     346                break;
     347            default:
     348                ASSERT_NOT_REACHED();
     349            }
     350            break;
     351        }
     352        case FilterOperation::BLUR: {
     353            float pixelRadius = static_cast<const BlurFilterOperation*>(&op)->stdDeviation().getFloatValue();
     354            webFilters.append(WebFilterOperation::createBlurFilter(pixelRadius));
     355            break;
     356        }
     357        case FilterOperation::DROP_SHADOW: {
     358            const DropShadowFilterOperation& dropShadowOp = *static_cast<const DropShadowFilterOperation*>(&op);
     359            webFilters.append(WebFilterOperation::createDropShadowFilter(WebPoint(dropShadowOp.x(), dropShadowOp.y()), dropShadowOp.stdDeviation(), dropShadowOp.color().rgb()));
     360            break;
     361        }
     362#if ENABLE(CSS_SHADERS)
     363        case FilterOperation::CUSTOM:
     364            return false; // Not supported.
     365#endif
     366        case FilterOperation::PASSTHROUGH:
     367        case FilterOperation::NONE:
     368            break;
     369        }
     370    }
     371    return true;
     372}
     373
    299374bool GraphicsLayerChromium::setFilters(const FilterOperations& filters)
    300375{
    301     m_layer.unwrap<LayerChromium>()->setFilters(filters);
     376    WebFilterOperations webFilters;
     377    if (!copyWebCoreFilterOperationsToWebFilterOperations(filters, webFilters))
     378        return false;
     379    m_layer.setFilters(webFilters);
    302380    return GraphicsLayer::setFilters(filters);
     381}
     382
     383void GraphicsLayerChromium::setBackgroundFilters(const FilterOperations& filters)
     384{
     385    WebFilterOperations webFilters;
     386    if (!copyWebCoreFilterOperationsToWebFilterOperations(filters, webFilters))
     387        return;
     388    m_layer.setBackgroundFilters(webFilters);
    303389}
    304390
    … …  
    593679void GraphicsLayerChromium::updateTransform()
    594680{
    595     primaryLayer().setTransform(WebKit::WebTransformationMatrix(m_transform));
     681    primaryLayer().setTransform(WebTransformationMatrix(m_transform));
    596682}
    597683
    598684void GraphicsLayerChromium::updateChildrenTransform()
    599685{
    600     primaryLayer().setSublayerTransform(WebKit::WebTransformationMatrix(m_childrenTransform));
     686    primaryLayer().setSublayerTransform(WebTransformationMatrix(m_childrenTransform));
    601687}
    602688

  • trunk/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h

    r117469 r117864  
    9090    // Returns true if filter can be rendered by the compositor
    9191    virtual bool setFilters(const FilterOperations&);
     92    void setBackgroundFilters(const FilterOperations&);
    9293
    9394    virtual void setNeedsDisplay();

  • trunk/Source/WebCore/platform/graphics/chromium/LayerChromium.cpp

    r117171 r117864  
    308308}
    309309
    310 void LayerChromium::setFilters(const FilterOperations& filters)
     310void LayerChromium::setFilters(const WebKit::WebFilterOperations& filters)
    311311{
    312312    if (m_filters == filters)
    … …  
    318318}
    319319
    320 void LayerChromium::setBackgroundFilters(const FilterOperations& backgroundFilters)
     320void LayerChromium::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
    321321{
    322322    if (m_backgroundFilters == backgroundFilters)
    … …  
    324324    m_backgroundFilters = backgroundFilters;
    325325    setNeedsCommit();
     326    if (!backgroundFilters.isEmpty())
     327        CCLayerTreeHost::setNeedsFilterContext(true);
    326328}
    327329
    … …  
    473475    layer->setDrawCheckerboardForMissingTiles(m_drawCheckerboardForMissingTiles);
    474476    layer->setDrawsContent(drawsContent());
    475     if (CCProxy::hasImplThread()) {
    476         // Since FilterOperations contains a vector of RefPtrs, we must deep copy the filters.
    477         FilterOperations filtersCopy;
    478         for (unsigned i = 0; i < m_filters.size(); ++i) {
    479             RefPtr<FilterOperation> clone = m_filters.at(i)->clone();
    480             if (clone)
    481                 filtersCopy.operations().append(clone);
    482         }
    483         layer->setFilters(filtersCopy);
    484     } else
    485         layer->setFilters(filters());
    486 
    487477    layer->setFilters(filters());
    488478    layer->setBackgroundFilters(backgroundFilters());

  • trunk/Source/WebCore/platform/graphics/chromium/LayerChromium.h

    r117469 r117864  
    3535#if USE(ACCELERATED_COMPOSITING)
    3636
    37 #include "FilterOperations.h"
    3837#include "FloatPoint.h"
    3938#include "GraphicsContext.h"
    … …  
    4746#include "cc/CCOcclusionTracker.h"
    4847
     48#include <public/WebFilterOperations.h>
    4949#include <wtf/OwnPtr.h>
    5050#include <wtf/PassOwnPtr.h>
    … …  
    5454#include <wtf/text/StringHash.h>
    5555#include <wtf/text/WTFString.h>
     56
    5657
    5758namespace WebCore {
    … …  
    116117    bool opacityIsAnimating() const;
    117118
    118     void setFilters(const FilterOperations&);
    119     const FilterOperations& filters() const { return m_filters; }
     119    void setFilters(const WebKit::WebFilterOperations&);
     120    const WebKit::WebFilterOperations& filters() { return m_filters; }
    120121
    121122    // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque
    122123    // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.
    123     void setBackgroundFilters(const FilterOperations&);
    124     const FilterOperations& backgroundFilters() const { return m_backgroundFilters; }
     124    void setBackgroundFilters(const WebKit::WebFilterOperations&);
     125    const WebKit::WebFilterOperations& backgroundFilters() { return m_backgroundFilters; }
    125126
    126127    virtual void setOpaque(bool);
    … …  
    319320    String m_debugName;
    320321    float m_opacity;
    321     FilterOperations m_filters;
    322     FilterOperations m_backgroundFilters;
     322    WebKit::WebFilterOperations m_filters;
     323    WebKit::WebFilterOperations m_backgroundFilters;
    323324    float m_anchorPointZ;
    324325    bool m_isDrawable;

  • trunk/Source/WebCore/platform/graphics/chromium/RenderSurfaceChromium.h

    r116472 r117864  
    3636#include "TextureManager.h"
    3737#include "TransformationMatrix.h"
     38#include <public/WebFilterOperations.h>
    3839#include <wtf/Noncopyable.h>
    3940
    … …  
    9192    void setClipRect(const IntRect& clipRect) { m_clipRect = clipRect; }
    9293
    93     void setFilters(const FilterOperations& filters) { m_filters = filters; }
    94     const FilterOperations& filters() const { return m_filters; }
     94    void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; }
     95    const WebKit::WebFilterOperations& filters() const { return m_filters; }
    9596
    96     void setBackgroundFilters(const FilterOperations& filters) { m_backgroundFilters = filters; }
    97     const FilterOperations& backgroundFilters() const { return m_backgroundFilters; }
     97    void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = filters; }
     98    const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
    9899
    99100    bool skipsDraw() const { return m_skipsDraw; }
    … …  
    130131    bool m_targetSurfaceTransformsAreAnimating;
    131132    bool m_screenSpaceTransformsAreAnimating;
    132     FilterOperations m_filters;
    133     FilterOperations m_backgroundFilters;
     133    WebKit::WebFilterOperations m_filters;
     134    WebKit::WebFilterOperations m_backgroundFilters;
    134135    IntRect m_clipRect;
    135136    Vector<RefPtr<LayerChromium> > m_layerList;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp

    r115397 r117864  
    3535#include "cc/CCDamageTracker.h"
    3636
    37 #include "FilterOperations.h"
    3837#include "cc/CCLayerImpl.h"
    3938#include "cc/CCLayerTreeHostCommon.h"
    4039#include "cc/CCMathUtil.h"
    4140#include "cc/CCRenderSurface.h"
     41#include <public/WebFilterOperations.h>
    4242
    4343namespace WebCore {
    … …  
    5959}
    6060
    61 static inline void expandDamageRectWithFilters(FloatRect& damageRect, const FilterOperations& filters)
     61static inline void expandDamageRectWithFilters(FloatRect& damageRect, const WebKit::WebFilterOperations& filters)
    6262{
    6363    int top, right, bottom, left;
    … …  
    6767}
    6868
    69 static inline void expandDamageRectInsideRectWithFilters(FloatRect& damageRect, const FloatRect& filterRect, const FilterOperations& filters)
     69static inline void expandDamageRectInsideRectWithFilters(FloatRect& damageRect, const FloatRect& filterRect, const WebKit::WebFilterOperations& filters)
    7070{
    7171    FloatRect expandedDamageRect = damageRect;
    … …  
    7676}
    7777
    78 void CCDamageTracker::updateDamageTrackingState(const Vector<CCLayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const FilterOperations& filters)
     78void CCDamageTracker::updateDamageTrackingState(const Vector<CCLayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const WebKit::WebFilterOperations& filters)
    7979{
    8080    //

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.h

    r115397 r117864  
    3232#include <wtf/Vector.h>
    3333
     34namespace WebKit {
     35class WebFilterOperations;
     36}
     37
    3438namespace WebCore {
    3539
    3640class CCLayerImpl;
    3741class CCRenderSurface;
    38 class FilterOperations;
    3942
    4043// Computes the region where pixels have actually changed on a RenderSurface. This region is used
    … …  
    4649
    4750    void forceFullDamageNextUpdate() { m_forceFullDamageNextUpdate = true; }
    48     void updateDamageTrackingState(const Vector<CCLayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const FilterOperations&);
     51    void updateDamageTrackingState(const Vector<CCLayerImpl*>& layerList, int targetSurfaceLayerID, bool targetSurfacePropertyChangedOnlyFromDescendant, const IntRect& targetSurfaceContentRect, CCLayerImpl* targetSurfaceMaskLayer, const WebKit::WebFilterOperations&);
    4952    const FloatRect& currentDamageRect() { return m_currentDamageRect; }
    5053

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.cpp

    r116195 r117864  
    386386}
    387387
    388 void CCLayerImpl::setFilters(const FilterOperations& filters)
     388void CCLayerImpl::setFilters(const WebKit::WebFilterOperations& filters)
    389389{
    390390    if (m_filters == filters)
    … …  
    395395}
    396396
    397 void CCLayerImpl::setBackgroundFilters(const FilterOperations& backgroundFilters)
     397void CCLayerImpl::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
    398398{
    399399    if (m_backgroundFilters == backgroundFilters)

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerImpl.h

    r116195 r117864  
    2828
    2929#include "Color.h"
    30 #include "FilterOperations.h"
    3130#include "FloatRect.h"
    3231#include "IntRect.h"
    … …  
    3736#include "cc/CCRenderSurface.h"
    3837#include "cc/CCSharedQuadState.h"
     38#include <public/WebFilterOperations.h>
    3939#include <wtf/OwnPtr.h>
    4040#include <wtf/PassRefPtr.h>
    … …  
    107107    Color backgroundColor() const { return m_backgroundColor; }
    108108
    109     void setFilters(const FilterOperations&);
    110     const FilterOperations& filters() const { return m_filters; }
    111 
    112     void setBackgroundFilters(const FilterOperations&);
    113     const FilterOperations& backgroundFilters() const { return m_backgroundFilters; }
     109    void setFilters(const WebKit::WebFilterOperations&);
     110    const WebKit::WebFilterOperations& filters() const { return m_filters; }
     111
     112    void setBackgroundFilters(const WebKit::WebFilterOperations&);
     113    const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
    114114
    115115    void setMasksToBounds(bool);
    … …  
    333333    String m_debugName;
    334334
    335     FilterOperations m_filters;
    336     FilterOperations m_backgroundFilters;
     335    WebKit::WebFilterOperations m_filters;
     336    WebKit::WebFilterOperations m_backgroundFilters;
    337337
    338338    TransformationMatrix m_drawTransform;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurface.cpp

    r116472 r117864  
    342342}
    343343
    344 SkBitmap CCRenderSurface::applyFilters(LayerRendererChromium* layerRenderer, const FilterOperations& filters, ManagedTexture* sourceTexture)
     344SkBitmap CCRenderSurface::applyFilters(LayerRendererChromium* layerRenderer, const WebKit::WebFilterOperations& filters, ManagedTexture* sourceTexture)
    345345{
    346346    if (filters.isEmpty())

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurface.h

    r116472 r117864  
    3030#if USE(ACCELERATED_COMPOSITING)
    3131
    32 #include "FilterOperations.h"
    3332#include "FloatRect.h"
    3433#include "IntRect.h"
    … …  
    3736#include "TransformationMatrix.h"
    3837#include "cc/CCLayerQuad.h"
     38#include <public/WebFilterOperations.h>
    3939#include <wtf/Noncopyable.h>
    4040
    … …  
    8484    void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
    8585
    86     void setFilters(const FilterOperations& filters) { m_filters = filters; }
    87     const FilterOperations& filters() const { return m_filters; }
    88     SkBitmap applyFilters(LayerRendererChromium*, const FilterOperations&, ManagedTexture* sourceTexture);
    89 
    90     void setBackgroundFilters(const FilterOperations& filters) { m_backgroundFilters = filters; }
    91     const FilterOperations& backgroundFilters() const { return m_backgroundFilters; }
     86    void setFilters(const WebKit::WebFilterOperations& filters) { m_filters = filters; }
     87    const WebKit::WebFilterOperations& filters() const { return m_filters; }
     88    SkBitmap applyFilters(LayerRendererChromium*, const WebKit::WebFilterOperations&, ManagedTexture* sourceTexture);
     89
     90    void setBackgroundFilters(const WebKit::WebFilterOperations& filters) { m_backgroundFilters = filters; }
     91    const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
    9292
    9393    void setNearestAncestorThatMovesPixels(CCRenderSurface* surface) { m_nearestAncestorThatMovesPixels = surface; }
    … …  
    184184    bool m_targetSurfaceTransformsAreAnimating;
    185185    bool m_screenSpaceTransformsAreAnimating;
    186     FilterOperations m_filters;
    187     FilterOperations m_backgroundFilters;
     186    WebKit::WebFilterOperations m_filters;
     187    WebKit::WebFilterOperations m_backgroundFilters;
    188188    IntRect m_clipRect;
    189189    Vector<CCLayerImpl*> m_layerList;

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceFilters.cpp

    r112193 r117864  
    3737#include "SkGpuDevice.h"
    3838#include "SkGrTexturePixelRef.h"
     39#include <public/WebFilterOperation.h>
     40#include <public/WebFilterOperations.h>
    3941
    4042namespace {
    … …  
    171173namespace WebCore {
    172174
    173 SkBitmap CCRenderSurfaceFilters::apply(const FilterOperations& filters, unsigned textureId, const FloatSize& size, GraphicsContext3D* context3D)
     175SkBitmap CCRenderSurfaceFilters::apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize& size, GraphicsContext3D* context3D)
    174176{
    175177    SkBitmap source;
    … …  
    197199        // locked during draw to prevent it be re-used as destination.
    198200        GrContext::TextureCacheEntry sourceEntry = dest;
    199         const FilterOperation* filterOperation = filters.at(i);
     201        const WebKit::WebFilterOperation& op = filters.at(i);
    200202        // Allocate a destination texture.
    201203        GrTextureDesc desc;
    … …  
    212214        SkCanvas canvas(&device);
    213215        canvas.clear(0x0);
    214         switch (filterOperation->getOperationType()) {
    215         case FilterOperation::BRIGHTNESS: {
    216             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    217             SkScalar matrix[20];
    218             getBrightnessMatrix(op->amount(), matrix);
    219             applyColorMatrix(&canvas, source, matrix);
    220             break;
    221         }
    222         case FilterOperation::CONTRAST: {
    223             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    224             SkScalar matrix[20];
    225             getContrastMatrix(op->amount(), matrix);
    226             applyColorMatrix(&canvas, source, matrix);
    227             break;
    228         }
    229         case FilterOperation::GRAYSCALE: {
    230             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    231             SkScalar matrix[20];
    232             getGrayscaleMatrix(1 - op->amount(), matrix);
    233             applyColorMatrix(&canvas, source, matrix);
    234             break;
    235         }
    236         case FilterOperation::SEPIA: {
    237             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    238             SkScalar matrix[20];
    239             getSepiaMatrix(1 - op->amount(), matrix);
    240             applyColorMatrix(&canvas, source, matrix);
    241             break;
    242         }
    243         case FilterOperation::SATURATE: {
    244             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    245             SkScalar matrix[20];
    246             getSaturateMatrix(op->amount(), matrix);
    247             applyColorMatrix(&canvas, source, matrix);
    248             break;
    249         }
    250         case FilterOperation::HUE_ROTATE: {
    251             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    252             SkScalar matrix[20];
    253             getHueRotateMatrix(op->amount(), matrix);
    254             applyColorMatrix(&canvas, source, matrix);
    255             break;
    256         }
    257         case FilterOperation::INVERT: {
    258             const BasicColorMatrixFilterOperation* op = static_cast<const BasicColorMatrixFilterOperation*>(filterOperation);
    259             SkScalar matrix[20];
    260             getInvertMatrix(op->amount(), matrix);
    261             applyColorMatrix(&canvas, source, matrix);
    262             break;
    263         }
    264         case FilterOperation::OPACITY: {
    265             const BasicComponentTransferFilterOperation* op = static_cast<const BasicComponentTransferFilterOperation*>(filterOperation);
    266             SkScalar matrix[20];
    267             getOpacityMatrix(op->amount(), matrix);
    268             applyColorMatrix(&canvas, source, matrix);
    269             break;
    270         }
    271         case FilterOperation::BLUR: {
    272             const BlurFilterOperation* op = static_cast<const BlurFilterOperation*>(filterOperation);
    273             float stdX = floatValueForLength(op->stdDeviation(), 0);
    274             float stdY = floatValueForLength(op->stdDeviation(), 1);
    275             SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdX, stdY));
     216        switch (op.type()) {
     217        case WebKit::WebFilterOperation::FilterTypeBrightness: {
     218            SkScalar matrix[20];
     219            getBrightnessMatrix(op.amount(), matrix);
     220            applyColorMatrix(&canvas, source, matrix);
     221            break;
     222        }
     223        case WebKit::WebFilterOperation::FilterTypeContrast: {
     224            SkScalar matrix[20];
     225            getContrastMatrix(op.amount(), matrix);
     226            applyColorMatrix(&canvas, source, matrix);
     227            break;
     228        }
     229        case WebKit::WebFilterOperation::FilterTypeGrayscale: {
     230            SkScalar matrix[20];
     231            getGrayscaleMatrix(1 - op.amount(), matrix);
     232            applyColorMatrix(&canvas, source, matrix);
     233            break;
     234        }
     235        case WebKit::WebFilterOperation::FilterTypeSepia: {
     236            SkScalar matrix[20];
     237            getSepiaMatrix(1 - op.amount(), matrix);
     238            applyColorMatrix(&canvas, source, matrix);
     239            break;
     240        }
     241        case WebKit::WebFilterOperation::FilterTypeSaturate: {
     242            SkScalar matrix[20];
     243            getSaturateMatrix(op.amount(), matrix);
     244            applyColorMatrix(&canvas, source, matrix);
     245            break;
     246        }
     247        case WebKit::WebFilterOperation::FilterTypeHueRotate: {
     248            SkScalar matrix[20];
     249            getHueRotateMatrix(op.amount(), matrix);
     250            applyColorMatrix(&canvas, source, matrix);
     251            break;
     252        }
     253        case WebKit::WebFilterOperation::FilterTypeInvert: {
     254            SkScalar matrix[20];
     255            getInvertMatrix(op.amount(), matrix);
     256            applyColorMatrix(&canvas, source, matrix);
     257            break;
     258        }
     259        case WebKit::WebFilterOperation::FilterTypeOpacity: {
     260            SkScalar matrix[20];
     261            getOpacityMatrix(op.amount(), matrix);
     262            applyColorMatrix(&canvas, source, matrix);
     263            break;
     264        }
     265        case WebKit::WebFilterOperation::FilterTypeBlur: {
     266            float stdDeviation = op.amount();
     267            SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(stdDeviation, stdDeviation));
    276268            SkPaint paint;
    277269            paint.setImageFilter(filter.get());
    … …  
    279271            break;
    280272        }
    281         case FilterOperation::DROP_SHADOW: {
    282             const DropShadowFilterOperation* op = static_cast<const DropShadowFilterOperation*>(filterOperation);
    283             SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(op->stdDeviation(), op->stdDeviation()));
    284             SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(op->color().rgb(), SkXfermode::kSrcIn_Mode));
     273        case WebKit::WebFilterOperation::FilterTypeDropShadow: {
     274            SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(op.amount(), op.amount()));
     275            SkAutoTUnref<SkColorFilter> colorFilter(SkColorFilter::CreateModeFilter(op.dropShadowColor(), SkXfermode::kSrcIn_Mode));
    285276            SkPaint paint;
    286277            paint.setImageFilter(blurFilter.get());
    … …  
    288279            paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
    289280            canvas.saveLayer(0, &paint);
    290             canvas.drawBitmap(source, op->x(), -op->y());
     281            canvas.drawBitmap(source, op.dropShadowOffset().x, -op.dropShadowOffset().y);
    291282            canvas.restore();
    292283            canvas.drawBitmap(source, 0, 0);
    293284            break;
    294285        }
    295         case FilterOperation::PASSTHROUGH:
    296286        default:
    297287            canvas.drawBitmap(source, 0, 0);

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderSurfaceFilters.h

    r107480 r117864  
    3232class SkBitmap;
    3333
     34namespace WebKit {
     35class WebFilterOperations;
     36}
     37
    3438namespace WebCore {
    35 class FilterOperations;
    3639class FloatSize;
    3740class GraphicsContext3D;
    … …  
    3942class CCRenderSurfaceFilters {
    4043public:
    41     static SkBitmap apply(const FilterOperations& filters, unsigned textureId, const FloatSize&, GraphicsContext3D*);
     44    static SkBitmap apply(const WebKit::WebFilterOperations& filters, unsigned textureId, const FloatSize&, GraphicsContext3D*);
    4245private:
    4346    CCRenderSurfaceFilters();

  • trunk/Source/WebCore/testing/Internals.cpp

    r117684 r117864  
    474474    }
    475475
    476     FilterOperations filters;
    477     filters.operations().append(BlurFilterOperation::create(Length(blurLength, Fixed), FilterOperation::BLUR));
     476    WebKit::WebFilterOperations filters;
     477    filters.append(WebKit::WebFilterOperation::createBlurFilter(blurLength));
    478478    platformLayer->setBackgroundFilters(filters);
    479479}

  • trunk/Source/WebKit/chromium/ChangeLog

    r117817 r117864  
     12012-05-21  James Robinson  <jamesr@chromium.org>
     2
     3        [chromium] Port chromium compositor to use WebFilterOperation(s)
     4        https://bugs.webkit.org/show_bug.cgi?id=87046
     5
     6        Reviewed by Adrienne Walker.
     7
     8        * WebKit.gypi:
     9        * src/AssertMatchingEnums.cpp:
     10        * src/WebLayer.cpp:
     11        (WebKit::WebLayer::setFilters):
     12        (WebKit::WebLayer::setBackgroundFilters):
     13        * tests/CCDamageTrackerTest.cpp:
     14        (WebKitTests::TEST_F):
     15        * tests/CCLayerImplTest.cpp:
     16        (WebCore::TEST):
     17        * tests/CCLayerTreeHostTest.cpp:
     18        (WTF::CCLayerTreeHostTestLayerOcclusionWithFilters::beginTest):
     19        * tests/CCOcclusionTrackerTest.cpp:
     20        (WebKitTests::CCOcclusionTrackerTest::createSurface):
     21        (WebKitTests::CCOcclusionTrackerTest::createDrawingSurface):
     22        (WebKitTests::CCOcclusionTrackerTestFilters::runMyTest):
     23        (WebKitTests::CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter::runMyTest):
     24        (WebKitTests::CCOcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice::runMyTest):
     25        (WebKitTests::CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip::runMyTest):
     26        (WebKitTests::CCOcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter::runMyTest):
     27        (WebKitTests::CCOcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded::runMyTest):
     28        (WebKitTests::CCOcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded::runMyTest):
     29        * tests/FilterOperationsTest.cpp: Added.
     30          Tests the existing behavior of WebCore::FilterOperations::getOutsets and makes sure WebFilterOperations'
     31          behavior matches.
     32        (WebKit):
     33        (WebKit::TEST):
     34        * tests/GraphicsLayerChromiumTest.cpp:
     35
    1362012-05-21  Joshua Bell  <jsbell@chromium.org>
    237

  • trunk/Source/WebKit/chromium/WebKit.gypi

    r117199 r117864  
    102102            'tests/FakeGraphicsContext3DTest.cpp',
    103103            'tests/FakeWebGraphicsContext3D.h',
     104            'tests/FilterOperationsTest.cpp',
    104105            'tests/FloatQuadTest.cpp',
    105106            'tests/FrameLoaderClientImplTest.cpp',

  • trunk/Source/WebKit/chromium/src/AssertMatchingEnums.cpp

    r117817 r117864  
    326326COMPILE_ASSERT_MATCHING_ENUM(WebEditingActionDropped, EditorInsertActionDropped);
    327327
    328 COMPILE_ASSERT_MATCHING_ENUM(WebBasicColorMatrixFilterOperation::BasicColorMatrixFilterTypeGrayscale, FilterOperation::GRAYSCALE);
    329 COMPILE_ASSERT_MATCHING_ENUM(WebBasicColorMatrixFilterOperation::BasicColorMatrixFilterTypeSepia, FilterOperation::SEPIA);
    330 COMPILE_ASSERT_MATCHING_ENUM(WebBasicColorMatrixFilterOperation::BasicColorMatrixFilterTypeSaturate, FilterOperation::SATURATE);
    331 COMPILE_ASSERT_MATCHING_ENUM(WebBasicColorMatrixFilterOperation::BasicColorMatrixFilterTypeHueRotate, FilterOperation::HUE_ROTATE);
    332 
    333 COMPILE_ASSERT_MATCHING_ENUM(WebBasicComponentTransferFilterOperation::BasicComponentTransferFilterTypeInvert, FilterOperation::INVERT);
    334 COMPILE_ASSERT_MATCHING_ENUM(WebBasicComponentTransferFilterOperation::BasicComponentTransferFilterTypeBrightness, FilterOperation::BRIGHTNESS);
    335 COMPILE_ASSERT_MATCHING_ENUM(WebBasicComponentTransferFilterOperation::BasicComponentTransferFilterTypeContrast, FilterOperation::CONTRAST);
    336 
    337328COMPILE_ASSERT_MATCHING_ENUM(WebFontDescription::GenericFamilyNone, FontDescription::NoFamily);
    338329COMPILE_ASSERT_MATCHING_ENUM(WebFontDescription::GenericFamilyStandard, FontDescription::StandardFamily);

  • trunk/Source/WebKit/chromium/src/WebLayer.cpp

    r117469 r117864  
    277277void WebLayer::setFilters(const WebFilterOperations& filters)
    278278{
    279     m_private->setFilters(filters.toFilterOperations());
     279    m_private->setFilters(filters);
    280280}
    281281
    282282void WebLayer::setBackgroundFilters(const WebFilterOperations& filters)
    283283{
    284     m_private->setBackgroundFilters(filters.toFilterOperations());
     284    m_private->setBackgroundFilters(filters);
    285285}
    286286

  • trunk/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp

    r115397 r117864  
    3434#include "cc/CCSingleThreadProxy.h"
    3535#include <gtest/gtest.h>
     36#include <public/WebFilterOperation.h>
     37#include <public/WebFilterOperations.h>
    3638
    3739using namespace WebCore;
     40using namespace WebKit;
    3841using namespace WTF;
    3942using namespace WebKitTests;
    … …  
    365368    CCLayerImpl* child = root->children()[0].get();
    366369
    367     FilterOperations filters;
    368     filters.operations().append(BlurFilterOperation::create(Length(5, WebCore::Fixed), FilterOperation::BLUR));
     370    WebFilterOperations filters;
     371    filters.append(WebFilterOperation::createBlurFilter(5));
    369372    int outsetTop, outsetRight, outsetBottom, outsetLeft;
    370373    filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
    … …  
    392395    CCLayerImpl* child2 = root->children()[1].get();
    393396
    394     FilterOperations filters;
    395     filters.operations().append(BlurFilterOperation::create(Length(2, WebCore::Fixed), FilterOperation::BLUR));
     397    WebFilterOperations filters;
     398    filters.append(WebFilterOperation::createBlurFilter(2));
    396399    int outsetTop, outsetRight, outsetBottom, outsetLeft;
    397400    filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
    … …  
    10191022    CCRenderSurface* targetSurface = root->renderSurface();
    10201023    targetSurface->clearLayerList();
    1021     targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, FilterOperations());
     1024    targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, WebFilterOperations());
    10221025
    10231026    FloatRect damageRect = targetSurface->damageTracker()->currentDamageRect();

  • trunk/Source/WebKit/chromium/tests/CCLayerImplTest.cpp

    r114081 r117864  
    3030#include <gmock/gmock.h>
    3131#include <gtest/gtest.h>
     32#include <public/WebFilterOperation.h>
     33#include <public/WebFilterOperations.h>
    3234
     35using namespace WebKit;
    3336using namespace WebCore;
    3437
    … …  
    8689    TransformationMatrix arbitraryTransform;
    8790    arbitraryTransform.scale3d(0.1, 0.2, 0.3);
    88     FilterOperations arbitraryFilters;
    89     arbitraryFilters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY));
     91    WebFilterOperations arbitraryFilters;
     92    arbitraryFilters.append(WebFilterOperation::createOpacityFilter(0.5));
    9093
    9194    // Changing these properties affects the entire subtree of layers.

  • trunk/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp

    r117825 r117864  
    3232#include "CompositorFakeWebGraphicsContext3D.h"
    3333#include "ContentLayerChromium.h"
    34 #include "FilterOperations.h"
    3534#include "GraphicsContext3DPrivate.h"
    3635#include "LayerChromium.h"
    … …  
    5049#include <gtest/gtest.h>
    5150#include <public/Platform.h>
     51#include <public/WebFilterOperation.h>
     52#include <public/WebFilterOperations.h>
    5253#include <wtf/Locker.h>
    5354#include <wtf/MainThread.h>
    … …  
    24292430
    24302431        {
    2431             FilterOperations filters;
    2432             filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY));
     2432            WebFilterOperations filters;
     2433            filters.append(WebFilterOperation::createOpacityFilter(0.5));
    24332434            child->setFilters(filters);
    24342435        }
    … …  
    24572458
    24582459        {
    2459             FilterOperations filters;
    2460             filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR));
     2460            WebFilterOperations filters;
     2461            filters.append(WebFilterOperation::createBlurFilter(10));
    24612462            child->setFilters(filters);
    24622463        }

  • trunk/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp

    r116472 r117864  
    2929#include "CCAnimationTestCommon.h"
    3030#include "CCOcclusionTrackerTestCommon.h"
    31 #include "FilterOperations.h"
    3231#include "LayerChromium.h"
    3332#include "Region.h"
    … …  
    3837#include "cc/CCLayerTreeHostCommon.h"
    3938#include "cc/CCSingleThreadProxy.h"
    40 
    4139#include <gmock/gmock.h>
    4240#include <gtest/gtest.h>
     41#include <public/WebFilterOperation.h>
     42#include <public/WebFilterOperations.h>
    4343
    4444using namespace WebCore;
     45using namespace WebKit;
    4546using namespace WebKitTests;
    4647
    … …  
    200201    {
    201202        typename Types::LayerType* layer = createLayer(parent, transform, position, bounds);
    202         FilterOperations filters;
    203         filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE));
     203        WebFilterOperations filters;
     204        filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
    204205        layer->setFilters(filters);
    205206        return layer;
    … …  
    247248    {
    248249        typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque);
    249         FilterOperations filters;
    250         filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE));
     250        WebFilterOperations filters;
     251        filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
    251252        layer->setFilters(filters);
    252253        return layer;
    … …  
    12221223        typename Types::ContentLayerType* opacityLayer = this->createDrawingLayer(parent, layerTransform, FloatPoint(30, 30), IntSize(500, 500), true);
    12231224
    1224         FilterOperations filters;
    1225         filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR));
     1225        WebFilterOperations filters;
     1226        filters.append(WebFilterOperation::createBlurFilter(10));
    12261227        blurLayer->setFilters(filters);
    12271228
    1228         filters.operations().clear();
    1229         filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE));
     1229        filters.clear();
     1230        filters.append(WebFilterOperation::createGrayscaleFilter(0.5));
    12301231        opaqueLayer->setFilters(filters);
    12311232
    1232         filters.operations().clear();
    1233         filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY));
     1233        filters.clear();
     1234        filters.append(WebFilterOperation::createOpacityFilter(0.5));
    12341235        opacityLayer->setFilters(filters);
    12351236
    … …  
    24962497
    24972498        // Filters make the layer own a surface.
    2498         FilterOperations filters;
    2499         filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Fixed), FilterOperation::BLUR));
     2499        WebFilterOperations filters;
     2500        filters.append(WebFilterOperation::createBlurFilter(10));
    25002501        filteredSurface->setBackgroundFilters(filters);
    25012502
    … …  
    26172618
    26182619        // Filters make the layers own surfaces.
    2619         FilterOperations filters;
    2620         filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR));
     2620        WebFilterOperations filters;
     2621        filters.append(WebFilterOperation::createBlurFilter(3));
    26212622        filteredSurface1->setBackgroundFilters(filters);
    26222623        filteredSurface2->setBackgroundFilters(filters);
    … …  
    26822683
    26832684        // Filters make the layer own a surface. This filter is large enough that it goes outside the bottom of the clippingSurface.
    2684         FilterOperations filters;
    2685         filters.operations().append(BlurFilterOperation::create(Length(12, WebCore::Fixed), FilterOperation::BLUR));
     2685        WebFilterOperations filters;
     2686        filters.append(WebFilterOperation::createBlurFilter(12));
    26862687        filteredSurface->setBackgroundFilters(filters);
    26872688
    … …  
    28052806
    28062807        // Filters make the layer own a surface.
    2807         FilterOperations filters;
    2808         filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR));
     2808        WebFilterOperations filters;
     2809        filters.append(WebFilterOperation::createBlurFilter(3));
    28092810        filteredSurface->setBackgroundFilters(filters);
    28102811
    … …  
    28542855
    28552856        // Filters make the layer own a surface.
    2856         FilterOperations filters;
    2857         filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR));
     2857        WebFilterOperations filters;
     2858        filters.append(WebFilterOperation::createBlurFilter(3));
    28582859        filteredSurface->setBackgroundFilters(filters);
    28592860
    … …  
    29042905
    29052906        // Filters make the layer own a surface.
    2906         FilterOperations filters;
    2907         filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR));
     2907        WebFilterOperations filters;
     2908        filters.append(WebFilterOperation::createBlurFilter(3));
    29082909        filteredSurface->setBackgroundFilters(filters);
    29092910

  • trunk/Source/WebKit/chromium/tests/GraphicsLayerChromiumTest.cpp

    r116786 r117864  
    2929#include "CCAnimationTestCommon.h"
    3030#include "GraphicsLayer.h"
     31#include "LayerChromium.h"
    3132#include <gtest/gtest.h>
    3233#include <wtf/PassOwnPtr.h>
Note: See TracChangeset for help on using the changeset viewer.