Implement SkImageFilter support in the compositor.

cc/damage_tracker_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCDamageTracker.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerSorter.h"
 #include "CCLayerTreeHostCommon.h"
 #include "cc/math_util.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 
 namespace {
 
 void executeCalculateDrawTransformsAndVisibility(LayerImpl* root, std::vector<LayerImpl*>& renderSurfaceLayerList)
@@ skipping 26 matching lines @@
     //   1. computing the render passes and layerlists
     //   2. updating all damage trackers in the correct order
     //   3. resetting all updateRects and propertyChanged flags for all layers and surfaces.
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     executeCalculateDrawTransformsAndVisibility(root, renderSurfaceLayerList);
 
     // Iterate back-to-front, so that damage correctly propagates from descendant surfaces to ancestors.
     for (int i = renderSurfaceLayerList.size() - 1; i >= 0; --i) {
         RenderSurfaceImpl* targetSurface = renderSurfaceLayerList[i]->renderSurface();
-        targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), targetSurface->surfacePropertyChangedOnlyFromDescendant(), targetSurface->contentRect(), renderSurfaceLayerList[i]->maskLayer(), renderSurfaceLayerList[i]->filters());
+        targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), targetSurface->surfacePropertyChangedOnlyFromDescendant(), targetSurface->contentRect(), renderSurfaceLayerList[i]->maskLayer(), renderSurfaceLayerList[i]->filters(), renderSurfaceLayerList[i]->filter());
     }
 
     root->resetAllChangeTrackingForSubtree();
 }
 
 scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<LayerImpl> child = LayerImpl::create(2);
 
@@ skipping 312 matching lines @@
     emulateDrawingOneFrame(root.get());
 
     // Damage position on the surface should be: position of updateRect (10, 11) relative to the child (100, 100), but expanded by the blur outsets.
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     FloatRect expectedDamageRect = FloatRect(110, 111, 12, 13);
     expectedDamageRect.move(-outsetLeft, -outsetTop);
     expectedDamageRect.expand(outsetLeft + outsetRight, outsetTop + outsetBottom);
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 }
 
+TEST_F(DamageTrackerTest, verifyDamageForImageFilter)
+{
+    scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
+    LayerImpl* child = root->children()[0];
+    FloatRect rootDamageRect, childDamageRect;
+
+    // Allow us to set damage on child too.
+    child->setDrawsContent(true);
+
+    SkAutoTUnref<SkImageFilter> filter(new SkBlurImageFilter(SkIntToScalar(2),
+                                                             SkIntToScalar(2)));
+    // Setting the filter will damage the whole surface.
+    clearDamageForAllSurfaces(root.get());
+    child->setFilter(filter);
+    emulateDrawingOneFrame(root.get());
+    rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
+    childDamageRect = child->renderSurface()->damageTracker()->currentDamageRect();
+    EXPECT_FLOAT_RECT_EQ(FloatRect(100, 100, 30, 30), rootDamageRect);
+    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 30), childDamageRect);
+
+    // CASE 1: Setting the update rect should damage the whole surface (for now)
+    clearDamageForAllSurfaces(root.get());
+    child->setUpdateRect(FloatRect(0, 0, 1, 1));
+    emulateDrawingOneFrame(root.get());
+
+    rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
+    childDamageRect = child->renderSurface()->damageTracker()->currentDamageRect();
+    EXPECT_FLOAT_RECT_EQ(FloatRect(100, 100, 30, 30), rootDamageRect);
+    EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 30), childDamageRect);
+}
+
 TEST_F(DamageTrackerTest, verifyDamageForBackgroundBlurredChild)
 {
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
     LayerImpl* child1 = root->children()[0];
     LayerImpl* child2 = root->children()[1];
 
     // Allow us to set damage on child1 too.
     child1->setDrawsContent(true);
 
     WebFilterOperations filters;
@@ skipping 683 matching lines @@
 {
     // Though it should never happen, its a good idea to verify that the damage tracker
     // does not crash when it receives an empty layerList.
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     root->createRenderSurface();
 
     ASSERT_TRUE(root == root->renderTarget());
     RenderSurfaceImpl* targetSurface = root->renderSurface();
     targetSurface->clearLayerLists();
-    targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, WebFilterOperations());
+    targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, WebFilterOperations(), 0);
 
     FloatRect damageRect = targetSurface->damageTracker()->currentDamageRect();
     EXPECT_TRUE(damageRect.isEmpty());
 }
 
 TEST_F(DamageTrackerTest, verifyDamageAccumulatesUntilReset)
 {
     // If damage is not cleared, it should accumulate.
 
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
@@ skipping 18 matching lines @@
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.isEmpty());
 
     // Damage should remain empty even after one frame, since there's yet no new damage
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.isEmpty());
 }
 
 } // namespace