cc: Use FilterOperations::MapRect in RenderSurfaceImpl::DrawableContentRect.

cc/trees/layer_tree_host_common_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 "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 28 matching lines @@
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_host_common_test.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/task_runner_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/effects/SkOffsetImageFilter.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() {}
@@ skipping 1341 matching lines @@
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(2U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(4U, render_surface_layer_list.size());
-  EXPECT_EQ(gfx::RectF(-30, -30, 160, 160),
+
+  // The rectangle enclosing child1 and child2 (0,0 50x50), expanded for the
+  // blur (-30,-30 110x110), and then scaled by the scale matrix
+  // (-60,-60 220x220).

[ajuma, 2016/06/06 18:08:21]

Thanks for adding this comment (and for the similar comments in your new tests).

+  EXPECT_EQ(gfx::RectF(-60, -60, 220, 220),
             parent->render_surface()->DrawableContentRect());
 }
 
+TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {
+  LayerImpl* root = root_layer();
+  LayerImpl* child = AddChild<LayerImpl>(root);
+  child->SetDrawsContent(true);
+
+  SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(100, 100), true, false,
+                               true);
+  SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(25, 25), true, false,
+                               true);
+
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateReferenceFilter(
+      SkOffsetImageFilter::Make(50, 50, nullptr)));
+  child->SetFilters(filters);
+
+  ExecuteCalculateDrawProperties(root);
+
+  // The render surface's size should be unaffected by the offset image filter;
+  // it need only have a drawable content rect large enough to contain the
+  // contents (at the new offset).
+  ASSERT_TRUE(child->render_surface());
+  EXPECT_EQ(gfx::RectF(50, 50, 25, 25),
+            child->render_surface()->DrawableContentRect());
+}
+
+TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilterHighDpi) {
+  const float device_scale_factor = 2.0f;
+
+  LayerImpl* root = root_layer();
+  root->layer_tree_impl()->SetDeviceScaleFactor(device_scale_factor);
+  LayerImpl* child = AddChild<LayerImpl>(root);
+  child->SetDrawsContent(true);
+
+  SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(100, 100), true, false,
+                               true);
+  SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(25, 25), true, false,
+                               true);
+
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateReferenceFilter(
+      SkOffsetImageFilter::Make(50, 50, nullptr)));
+  child->SetFilters(filters);
+
+  ExecuteCalculateDrawProperties(root, device_scale_factor);
+
+  // The render surface's size should be unaffected by the offset image filter;
+  // it need only have a drawable content rect large enough to contain the
+  // contents (at the new offset). All coordinates should be scaled by 2,
+  // corresponding to the device scale factor.
+  ASSERT_TRUE(child->render_surface());
+  EXPECT_EQ(gfx::RectF(100, 100, 50, 50),
+            child->render_surface()->DrawableContentRect());
+}
+
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   child->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
@@ skipping 8712 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc