text: // 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/damage_tracker.h"
  
  #include "cc/base/math_util.h"
  #include "cc/layers/layer_impl.h"
  #include "cc/output/filter_operation.h"
  #include "cc/output/filter_operations.h"
  #include "cc/test/fake_impl_proxy.h"
  #include "cc/test/fake_layer_tree_host_impl.h"
  #include "cc/test/geometry_test_utils.h"
  #include "cc/test/test_shared_bitmap_manager.h"
  #include "cc/trees/layer_tree_host_common.h"
  #include "cc/trees/single_thread_proxy.h"
  #include "testing/gtest/include/gtest/gtest.h"
  #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  #include "ui/gfx/quad_f.h"
  
  namespace cc {
  namespace {
  
  void ExecuteCalculateDrawProperties(LayerImpl* root,
                                      LayerImplList& render_surface_layer_list) {
    // Sanity check: The test itself should create the root layer's render
    //               surface, so that the surface (and its damage tracker) can
    //               persist across multiple calls to this function.
    ASSERT_TRUE(root->render_surface());
    ASSERT_FALSE(render_surface_layer_list.size());
  
    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
        root, root->bounds(), &render_surface_layer_list);
    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
  }
  
  void ClearDamageForAllSurfaces(LayerImpl* layer) {
    if (layer->render_surface())
      layer->render_surface()->damage_tracker()->DidDrawDamagedArea();
  
    // Recursively clear damage for any existing surface.
    for (size_t i = 0; i < layer->children().size(); ++i)
      ClearDamageForAllSurfaces(layer->children()[i]);
  }
  
  void EmulateDrawingOneFrame(LayerImpl* root) {
    // This emulates only steps that are relevant to testing the damage tracker:
    //   1. computing the render passes and layerlists
    //   2. updating all damage trackers in the correct order
    //   3. resetting all update_rects and property_changed flags for all layers
    //      and surfaces.
  
    LayerImplList render_surface_layer_list;
    ExecuteCalculateDrawProperties(root, render_surface_layer_list);
  
    // Iterate back-to-front, so that damage correctly propagates from descendant
    // surfaces to ancestors.
    for (int i = render_surface_layer_list.size() - 1; i >= 0; --i) {
      RenderSurfaceImpl* target_surface =
              render_surface_layer_list[i]->render_surface();
      target_surface->damage_tracker()->UpdateDamageTrackingState(
          target_surface->layer_list(),
          target_surface->OwningLayerId(),
          target_surface->SurfacePropertyChangedOnlyFromDescendant(),
          target_surface->content_rect(),
          render_surface_layer_list[i]->mask_layer(),
          render_surface_layer_list[i]->filters());
    }
  
    root->ResetAllChangeTrackingForSubtree();
  }
  
  class DamageTrackerTest : public testing::Test {
   public:
    DamageTrackerTest() : host_impl_(&proxy_, &shared_bitmap_manager_) {}
  
    scoped_ptr<LayerImpl> CreateTestTreeWithOneSurface() {
      scoped_ptr<LayerImpl> root =
              LayerImpl::Create(host_impl_.active_tree(), 1);
      scoped_ptr<LayerImpl> child =
              LayerImpl::Create(host_impl_.active_tree(), 2);
  
      root->SetPosition(gfx::PointF());
      root->SetAnchorPoint(gfx::PointF());
      root->SetBounds(gfx::Size(500, 500));
      root->SetContentBounds(gfx::Size(500, 500));
      root->SetDrawsContent(true);
      root->CreateRenderSurface();
      root->render_surface()->SetContentRect(gfx::Rect(0, 0, 500, 500));
  
      child->SetPosition(gfx::PointF(100.f, 100.f));
      child->SetAnchorPoint(gfx::PointF());
      child->SetBounds(gfx::Size(30, 30));
      child->SetContentBounds(gfx::Size(30, 30));
      child->SetDrawsContent(true);
      root->AddChild(child.Pass());
  
      return root.Pass();
    }
  
    scoped_ptr<LayerImpl> CreateTestTreeWithTwoSurfaces() {
      // This test tree has two render surfaces: one for the root, and one for
      // child1. Additionally, the root has a second child layer, and child1 has
      // two children of its own.
  
      scoped_ptr<LayerImpl> root =
              LayerImpl::Create(host_impl_.active_tree(), 1);
      scoped_ptr<LayerImpl> child1 =
              LayerImpl::Create(host_impl_.active_tree(), 2);
      scoped_ptr<LayerImpl> child2 =
              LayerImpl::Create(host_impl_.active_tree(), 3);
      scoped_ptr<LayerImpl> grand_child1 =
              LayerImpl::Create(host_impl_.active_tree(), 4);
      scoped_ptr<LayerImpl> grand_child2 =
              LayerImpl::Create(host_impl_.active_tree(), 5);
  
      root->SetPosition(gfx::PointF());
      root->SetAnchorPoint(gfx::PointF());
      root->SetBounds(gfx::Size(500, 500));
      root->SetContentBounds(gfx::Size(500, 500));
      root->SetDrawsContent(true);
      root->CreateRenderSurface();
      root->render_surface()->SetContentRect(gfx::Rect(0, 0, 500, 500));
  
      child1->SetPosition(gfx::PointF(100.f, 100.f));
      child1->SetAnchorPoint(gfx::PointF());
      child1->SetBounds(gfx::Size(30, 30));
      child1->SetContentBounds(gfx::Size(30, 30));
      // With a child that draws_content, opacity will cause the layer to create
      // its own RenderSurface. This layer does not draw, but is intended to
      // create its own RenderSurface. TODO: setting opacity and
      // ForceRenderSurface may be redundant here.
      child1->SetOpacity(0.5f);
      child1->SetDrawsContent(false);
      child1->SetForceRenderSurface(true);
  
      child2->SetPosition(gfx::PointF(11.f, 11.f));
      child2->SetAnchorPoint(gfx::PointF());
      child2->SetBounds(gfx::Size(18, 18));
      child2->SetContentBounds(gfx::Size(18, 18));
      child2->SetDrawsContent(true);
  
      grand_child1->SetPosition(gfx::PointF(200.f, 200.f));
      grand_child1->SetAnchorPoint(gfx::PointF());
      grand_child1->SetBounds(gfx::Size(6, 8));
      grand_child1->SetContentBounds(gfx::Size(6, 8));
      grand_child1->SetDrawsContent(true);
  
      grand_child2->SetPosition(gfx::PointF(190.f, 190.f));
      grand_child2->SetAnchorPoint(gfx::PointF());
      grand_child2->SetBounds(gfx::Size(6, 8));
      grand_child2->SetContentBounds(gfx::Size(6, 8));
      grand_child2->SetDrawsContent(true);
  
      child1->AddChild(grand_child1.Pass());
      child1->AddChild(grand_child2.Pass());
      root->AddChild(child1.Pass());
      root->AddChild(child2.Pass());
  
      return root.Pass();
    }
  
    scoped_ptr<LayerImpl> CreateAndSetUpTestTreeWithOneSurface() {
      scoped_ptr<LayerImpl> root = CreateTestTreeWithOneSurface();
  
      // Setup includes going past the first frame which always damages
      // everything, so that we can actually perform specific tests.
      EmulateDrawingOneFrame(root.get());
  
      return root.Pass();
    }
  
    scoped_ptr<LayerImpl> CreateAndSetUpTestTreeWithTwoSurfaces() {
      scoped_ptr<LayerImpl> root = CreateTestTreeWithTwoSurfaces();
  
      // Setup includes going past the first frame which always damages
      // everything, so that we can actually perform specific tests.
      EmulateDrawingOneFrame(root.get());
  
      return root.Pass();
    }
  
   protected:
    FakeImplProxy proxy_;
    TestSharedBitmapManager shared_bitmap_manager_;
    FakeLayerTreeHostImpl host_impl_;
  };
  
  TEST_F(DamageTrackerTest, SanityCheckTestTreeWithOneSurface) {
    // Sanity check that the simple test tree will actually produce the expected
    // render surfaces and layer lists.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
  
    EXPECT_EQ(2u, root->render_surface()->layer_list().size());
    EXPECT_EQ(1, root->render_surface()->layer_list()[0]->id());
    EXPECT_EQ(2, root->render_surface()->layer_list()[1]->id());
  
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 500.f, 500.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) {
    // Sanity check that the complex test tree will actually produce the expected
    // render surfaces and layer lists.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
  
    LayerImpl* child1 = root->children()[0];
    LayerImpl* child2 = root->children()[1];
    gfx::RectF child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    ASSERT_TRUE(child1->render_surface());
    EXPECT_FALSE(child2->render_surface());
    EXPECT_EQ(3u, root->render_surface()->layer_list().size());
    EXPECT_EQ(2u, child1->render_surface()->layer_list().size());
  
    // The render surface for child1 only has a content_rect that encloses
    // grand_child1 and grand_child2, because child1 does not draw content.
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 16.f, 18.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 500.f, 500.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    // CASE 1: Setting the update rect should cause the corresponding damage to
    //         the surface.
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
    EmulateDrawingOneFrame(root.get());
  
    // Damage position on the surface should be: position of update_rect (10, 11)
    // relative to the child (100, 100).
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(110.f, 111.f, 12.f, 13.f), root_damage_rect);
  
    // CASE 2: The same update rect twice in a row still produces the same
    //         damage.
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(110.f, 111.f, 12.f, 13.f), root_damage_rect);
  
    // CASE 3: Setting a different update rect should cause damage on the new
    //         update region, but no additional exposed old region.
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(20.f, 25.f, 1.f, 2.f));
    EmulateDrawingOneFrame(root.get());
  
    // Damage position on the surface should be: position of update_rect (20, 25)
    // relative to the child (100, 100).
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(120.f, 125.f, 1.f, 2.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    // CASE 1: The layer's property changed flag takes priority over update rect.
    //
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
    child->SetOpacity(0.5f);
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check - we should not have accidentally created a separate render
    // surface for the translucent layer.
    ASSERT_FALSE(child->render_surface());
    ASSERT_EQ(2u, root->render_surface()->layer_list().size());
  
    // Damage should be the entire child layer in target_surface space.
    gfx::RectF expected_rect = gfx::RectF(100.f, 100.f, 30.f, 30.f);
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
  
    // CASE 2: If a layer moves due to property change, it damages both the new
    //         location and the old (exposed) location. The old location is the
    //         entire old layer, not just the update_rect.
  
    // Cycle one frame of no change, just to sanity check that the next rect is
    // not because of the old damage state.
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  
    // Then, test the actual layer movement.
    ClearDamageForAllSurfaces(root.get());
    child->SetPosition(gfx::PointF(200.f, 230.f));
    EmulateDrawingOneFrame(root.get());
  
    // Expect damage to be the combination of the previous one and the new one.
    expected_rect.Union(gfx::RectF(200, 230, 30, 30));
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForTransformedLayer) {
    // If a layer is transformed, the damage rect should still enclose the entire
    // transformed layer.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    gfx::Transform rotation;
    rotation.Rotate(45.0);
  
    ClearDamageForAllSurfaces(root.get());
    child->SetAnchorPoint(gfx::PointF(0.5f, 0.5f));
    child->SetPosition(gfx::PointF(85.f, 85.f));
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that the layer actually moved to (85, 85), damaging its old
    // location and new location.
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(85.f, 85.f, 45.f, 45.f), root_damage_rect);
  
    // With the anchor on the layer's center, now we can test the rotation more
    // intuitively, since it applies about the layer's anchor.
    ClearDamageForAllSurfaces(root.get());
    child->SetTransform(rotation);
    EmulateDrawingOneFrame(root.get());
  
    // Since the child layer is square, rotation by 45 degrees about the center
    // should increase the size of the expected rect by sqrt(2), centered around
    // (100, 100). The old exposed region should be fully contained in the new
    // region.
    float expected_width = 30.f * sqrt(2.f);
    float expected_position = 100.f - 0.5f * expected_width;
    gfx::RectF expected_rect(
        expected_position, expected_position, expected_width, expected_width);
    root_damage_rect =
        root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForPerspectiveClippedLayer) {
    // If a layer has a perspective transform that causes w < 0, then not
    // clipping the layer can cause an invalid damage rect. This test checks that
    // the w < 0 case is tracked properly.
    //
    // The transform is constructed so that if w < 0 clipping is not performed,
    // the incorrect rect will be very small, specifically: position (500.972504,
    // 498.544617) and size 0.056610 x 2.910767.  Instead, the correctly
    // transformed rect should actually be very huge (i.e. in theory, -infinity
    // on the left), and positioned so that the right-most bound rect will be
    // approximately 501 units in root surface space.
    //
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    gfx::Transform transform;
    transform.Translate3d(500.0, 500.0, 0.0);
    transform.ApplyPerspectiveDepth(1.0);
    transform.RotateAboutYAxis(45.0);
    transform.Translate3d(-50.0, -50.0, 0.0);
  
    // Set up the child
    child->SetPosition(gfx::PointF(0.f, 0.f));
    child->SetBounds(gfx::Size(100, 100));
    child->SetContentBounds(gfx::Size(100, 100));
    child->SetTransform(transform);
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that the child layer's bounds would actually get clipped by
    // w < 0, otherwise this test is not actually testing the intended scenario.
    gfx::QuadF test_quad(gfx::RectF(gfx::PointF(), gfx::SizeF(100.f, 100.f)));
    bool clipped = false;
    MathUtil::MapQuad(transform, test_quad, &clipped);
    EXPECT_TRUE(clipped);
  
    // Damage the child without moving it.
    ClearDamageForAllSurfaces(root.get());
    child->SetOpacity(0.5f);
    EmulateDrawingOneFrame(root.get());
  
    // The expected damage should cover the entire root surface (500x500), but we
    // don't care whether the damage rect was clamped or is larger than the
    // surface for this test.
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    gfx::RectF damage_we_care_about =
            gfx::RectF(gfx::PointF(), gfx::SizeF(500.f, 500.f));
    EXPECT_TRUE(root_damage_rect.Contains(damage_we_care_about));
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* surface = root->children()[0];
    LayerImpl* child = surface->children()[0];
  
    FilterOperations filters;
    filters.Append(FilterOperation::CreateBlurFilter(5.f));
    int outset_top, outset_right, outset_bottom, outset_left;
    filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left);
  
    // Setting the filter will damage the whole surface.
    ClearDamageForAllSurfaces(root.get());
    surface->SetFilters(filters);
    EmulateDrawingOneFrame(root.get());
  
    // Setting the update rect should cause the corresponding damage to the
    // surface, blurred based on the size of the blur filter.
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(1.f, 2.f, 3.f, 4.f));
    EmulateDrawingOneFrame(root.get());
  
    // Damage position on the surface should be: position of update_rect (1, 2)
    // relative to the child (300, 300), but expanded by the blur outsets.
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    gfx::RectF expected_damage_rect =
            gfx::RectF(301.f, 302.f, 3.f, 4.f);
  
    expected_damage_rect.Inset(-outset_left,
                               -outset_top,
                               -outset_right,
                               -outset_bottom);
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForImageFilter) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
    gfx::RectF root_damage_rect, child_damage_rect;
  
    // Allow us to set damage on child too.
    child->SetDrawsContent(true);
  
    skia::RefPtr<SkImageFilter> filter =
            skia::AdoptRef(new SkBlurImageFilter(SkIntToScalar(2),
                                                 SkIntToScalar(2)));
    FilterOperations filters;
    filters.Append(FilterOperation::CreateReferenceFilter(filter));
  
    // Setting the filter will damage the whole surface.
    ClearDamageForAllSurfaces(root.get());
    child->SetFilters(filters);
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(100.f, 100.f, 30.f, 30.f), root_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 30.f, 30.f), child_damage_rect);
  
    // CASE 1: Setting the update rect should damage the whole surface (for now)
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 1.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(100.f, 100.f, 30.f, 30.f), root_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 30.f, 30.f), child_damage_rect);
  }
  
  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);
  
    FilterOperations filters;
    filters.Append(FilterOperation::CreateBlurFilter(2.f));
    int outset_top, outset_right, outset_bottom, outset_left;
    filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left);
  
    // Setting the filter will damage the whole surface.
    ClearDamageForAllSurfaces(root.get());
    child1->SetBackgroundFilters(filters);
    EmulateDrawingOneFrame(root.get());
  
    // CASE 1: Setting the update rect should cause the corresponding damage to
    //         the surface, blurred based on the size of the child's background
    //         blur filter.
    ClearDamageForAllSurfaces(root.get());
    root->SetUpdateRect(gfx::RectF(297.f, 297.f, 2.f, 2.f));
    EmulateDrawingOneFrame(root.get());
  
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage position on the surface should be a composition of the damage on
    // the root and on child2.  Damage on the root should be: position of
    // update_rect (297, 297), but expanded by the blur outsets.
    gfx::RectF expected_damage_rect =
            gfx::RectF(297.f, 297.f, 2.f, 2.f);
  
    expected_damage_rect.Inset(-outset_left,
                               -outset_top,
                               -outset_right,
                               -outset_bottom);
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  
    // CASE 2: Setting the update rect should cause the corresponding damage to
    //         the surface, blurred based on the size of the child's background
    //         blur filter. Since the damage extends to the right/bottom outside
    //         of the blurred layer, only the left/top should end up expanded.
    ClearDamageForAllSurfaces(root.get());
    root->SetUpdateRect(gfx::RectF(297.f, 297.f, 30.f, 30.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage position on the surface should be a composition of the damage on
    // the root and on child2.  Damage on the root should be: position of
    // update_rect (297, 297), but expanded on the left/top by the blur outsets.
    expected_damage_rect =
            gfx::RectF(297.f, 297.f, 30.f, 30.f);
  
    expected_damage_rect.Inset(-outset_left,
                               -outset_top,
                               0,
                               0);
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  
    // CASE 3: Setting this update rect outside the blurred content_bounds of the
    //         blurred child1 will not cause it to be expanded.
    ClearDamageForAllSurfaces(root.get());
    root->SetUpdateRect(gfx::RectF(30.f, 30.f, 2.f, 2.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage on the root should be: position of update_rect (30, 30), not
    // expanded.
    expected_damage_rect =
            gfx::RectF(30.f, 30.f, 2.f, 2.f);
  
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  
    // CASE 4: Setting this update rect inside the blurred content_bounds but
    //         outside the original content_bounds of the blurred child1 will
    //         cause it to be expanded.
    ClearDamageForAllSurfaces(root.get());
    root->SetUpdateRect(gfx::RectF(99.f, 99.f, 1.f, 1.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage on the root should be: position of update_rect (99, 99), expanded by
    // the blurring on child1, but since it is 1 pixel outside the layer, the
    // expanding should be reduced by 1.
    expected_damage_rect =
            gfx::RectF(99.f, 99.f, 1.f, 1.f);
  
    expected_damage_rect.Inset(-outset_left + 1,
                               -outset_top + 1,
                               -outset_right,
                               -outset_bottom);
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  
    // CASE 5: Setting the update rect on child2, which is above child1, will
    // not get blurred by child1, so it does not need to get expanded.
    ClearDamageForAllSurfaces(root.get());
    child2->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 1.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage on child2 should be: position of update_rect offset by the child's
    // position (11, 11), and not expanded by anything.
    expected_damage_rect =
            gfx::RectF(11.f, 11.f, 1.f, 1.f);
  
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  
    // CASE 6: Setting the update rect on child1 will also blur the damage, so
    //         that any pixels needed for the blur are redrawn in the current
    //         frame.
    ClearDamageForAllSurfaces(root.get());
    child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 1.f));
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    // Damage on child1 should be: position of update_rect offset by the child's
    // position (100, 100), and expanded by the damage.
    expected_damage_rect =
            gfx::RectF(100.f, 100.f, 1.f, 1.f);
  
    expected_damage_rect.Inset(-outset_left,
                               -outset_top,
                               -outset_right,
                               -outset_bottom);
    EXPECT_FLOAT_RECT_EQ(expected_damage_rect, root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingLayer) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child1 = root->children()[0];
  
    // CASE 1: Adding a new layer should cause the appropriate damage.
    //
    ClearDamageForAllSurfaces(root.get());
    {
      scoped_ptr<LayerImpl> child2 =
              LayerImpl::Create(host_impl_.active_tree(), 3);
      child2->SetPosition(gfx::PointF(400.f, 380.f));
      child2->SetAnchorPoint(gfx::PointF());
      child2->SetBounds(gfx::Size(6, 8));
      child2->SetContentBounds(gfx::Size(6, 8));
      child2->SetDrawsContent(true);
      root->AddChild(child2.Pass());
    }
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check - all 3 layers should be on the same render surface; render
    // surfaces are tested elsewhere.
    ASSERT_EQ(3u, root->render_surface()->layer_list().size());
  
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(400.f, 380.f, 6.f, 8.f), root_damage_rect);
  
    // CASE 2: If the layer is removed, its entire old layer becomes exposed, not
    //         just the last update rect.
  
    // Advance one frame without damage so that we know the damage rect is not
    // leftover from the previous case.
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  
    // Then, test removing child1.
    root->RemoveChild(child1);
    child1 = NULL;
    EmulateDrawingOneFrame(root.get());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(100.f, 100.f, 30.f, 30.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForNewUnchangedLayer) {
    // If child2 is added to the layer tree, but it doesn't have any explicit
    // damage of its own, it should still indeed damage the target surface.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
  
    ClearDamageForAllSurfaces(root.get());
    {
      scoped_ptr<LayerImpl> child2 =
              LayerImpl::Create(host_impl_.active_tree(), 3);
      child2->SetPosition(gfx::PointF(400.f, 380.f));
      child2->SetAnchorPoint(gfx::PointF());
      child2->SetBounds(gfx::Size(6, 8));
      child2->SetContentBounds(gfx::Size(6, 8));
      child2->SetDrawsContent(true);
      child2->ResetAllChangeTrackingForSubtree();
      // Sanity check the initial conditions of the test, if these asserts
      // trigger, it means the test no longer actually covers the intended
      // scenario.
      ASSERT_FALSE(child2->LayerPropertyChanged());
      ASSERT_TRUE(child2->update_rect().IsEmpty());
      root->AddChild(child2.Pass());
    }
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check - all 3 layers should be on the same render surface; render
    // surfaces are tested elsewhere.
    ASSERT_EQ(3u, root->render_surface()->layer_list().size());
  
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(400.f, 380.f, 6.f, 8.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child1 = root->children()[0];
  
    // In this test we don't want the above tree manipulation to be considered
    // part of the same frame.
    ClearDamageForAllSurfaces(root.get());
    {
      scoped_ptr<LayerImpl> child2 =
              LayerImpl::Create(host_impl_.active_tree(), 3);
      child2->SetPosition(gfx::PointF(400.f, 380.f));
      child2->SetAnchorPoint(gfx::PointF());
      child2->SetBounds(gfx::Size(6, 8));
      child2->SetContentBounds(gfx::Size(6, 8));
      child2->SetDrawsContent(true);
      root->AddChild(child2.Pass());
    }
    LayerImpl* child2 = root->children()[1];
    EmulateDrawingOneFrame(root.get());
  
    // Damaging two layers simultaneously should cause combined damage.
    // - child1 update rect in surface space: gfx::RectF(100.f, 100.f, 1.f, 2.f);
    // - child2 update rect in surface space: gfx::RectF(400.f, 380.f, 3.f, 4.f);
    ClearDamageForAllSurfaces(root.get());
    child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 2.f));
    child2->SetUpdateRect(gfx::RectF(0.f, 0.f, 3.f, 4.f));
    EmulateDrawingOneFrame(root.get());
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(
        gfx::RectF(100.f, 100.f, 303.f, 284.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForNestedSurfaces) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    LayerImpl* child2 = root->children()[1];
    LayerImpl* grand_child1 = root->children()[0]->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    // CASE 1: Damage to a descendant surface should propagate properly to
    //         ancestor surface.
    ClearDamageForAllSurfaces(root.get());
    grand_child1->SetOpacity(0.5f);
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(200.f, 200.f, 6.f, 8.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(300.f, 300.f, 6.f, 8.f), root_damage_rect);
  
    // CASE 2: Same as previous case, but with additional damage elsewhere that
    //         should be properly unioned.
    // - child1 surface damage in root surface space:
    //   gfx::RectF(300.f, 300.f, 6.f, 8.f);
    // - child2 damage in root surface space:
    //   gfx::RectF(11.f, 11.f, 18.f, 18.f);
    ClearDamageForAllSurfaces(root.get());
    grand_child1->SetOpacity(0.7f);
    child2->SetOpacity(0.7f);
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(200.f, 200.f, 6.f, 8.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(11.f, 11.f, 295.f, 297.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromDescendantLayer) {
    // If descendant layer changes and affects the content bounds of the render
    // surface, then the entire descendant surface should be damaged, and it
    // should damage its ancestor surface with the old and new surface regions.
  
    // This is a tricky case, since only the first grand_child changes, but the
    // entire surface should be marked dirty.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    LayerImpl* grand_child1 = root->children()[0]->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    ClearDamageForAllSurfaces(root.get());
    grand_child1->SetPosition(gfx::PointF(195.f, 205.f));
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    // The new surface bounds should be damaged entirely, even though only one of
    // the layers changed.
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 11.f, 23.f), child_damage_rect);
  
    // Damage to the root surface should be the union of child1's *entire* render
    // surface (in target space), and its old exposed area (also in target
    // space).
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(290.f, 290.f, 16.f, 23.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
    // An ancestor/owning layer changes that affects the position/transform of
    // the render surface. Note that in this case, the layer_property_changed flag
    // already propagates to the subtree (tested in LayerImpltest), which damages
    // the entire child1 surface, but the damage tracker still needs the correct
    // logic to compute the exposed region on the root surface.
  
    // TODO(shawnsingh): the expectations of this test case should change when we
    // add support for a unique scissor_rect per RenderSurface. In that case, the
    // child1 surface should be completely unchanged, since we are only
    // transforming it, while the root surface would be damaged appropriately.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    ClearDamageForAllSurfaces(root.get());
    child1->SetPosition(gfx::PointF(50.f, 50.f));
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    // The new surface bounds should be damaged entirely.
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 16.f, 18.f), child_damage_rect);
  
    // The entire child1 surface and the old exposed child1 surface should damage
    // the root surface.
    //  - old child1 surface in target space: gfx::RectF(290.f, 290.f, 16.f, 18.f)
    //  - new child1 surface in target space: gfx::RectF(240.f, 240.f, 16.f, 18.f)
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(240.f, 240.f, 66.f, 68.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingRenderSurfaces) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    // CASE 1: If a descendant surface disappears, its entire old area becomes
    //         exposed.
    ClearDamageForAllSurfaces(root.get());
    child1->SetOpacity(1.f);
    child1->SetForceRenderSurface(false);
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that there is only one surface now.
    ASSERT_FALSE(child1->render_surface());
    ASSERT_EQ(4u, root->render_surface()->layer_list().size());
  
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(290.f, 290.f, 16.f, 18.f), root_damage_rect);
  
    // CASE 2: If a descendant surface appears, its entire old area becomes
    //         exposed.
  
    // Cycle one frame of no change, just to sanity check that the next rect is
    // not because of the old damage state.
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  
    // Then change the tree so that the render surface is added back.
    ClearDamageForAllSurfaces(root.get());
    child1->SetOpacity(0.5f);
    child1->SetForceRenderSurface(true);
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that there is a new surface now.
    ASSERT_TRUE(child1->render_surface());
    EXPECT_EQ(3u, root->render_surface()->layer_list().size());
    EXPECT_EQ(2u, child1->render_surface()->layer_list().size());
  
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(190.f, 190.f, 16.f, 18.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(290.f, 290.f, 16.f, 18.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyNoDamageWhenNothingChanged) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    // CASE 1: If nothing changes, the damage rect should be empty.
    //
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(child_damage_rect.IsEmpty());
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  
    // CASE 2: If nothing changes twice in a row, the damage rect should still be
    //         empty.
    //
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(child_damage_rect.IsEmpty());
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  }
  
  TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    gfx::RectF child_damage_rect;
    gfx::RectF root_damage_rect;
  
    // In our specific tree, the update rect of child1 should not cause any
    // damage to any surface because it does not actually draw content.
    ClearDamageForAllSurfaces(root.get());
    child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 2.f));
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(child_damage_rect.IsEmpty());
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    LayerImpl* grand_child1 = child1->children()[0];
    LayerImpl* grand_child2 = child1->children()[1];
  
    // Damage on a surface that has a reflection should cause the target surface
    // to receive the surface's damage and the surface's reflected damage.
  
    // For this test case, we modify grand_child2, and add grand_child3 to extend
    // the bounds of child1's surface. This way, we can test reflection changes
    // without changing content_bounds of the surface.
    grand_child2->SetPosition(gfx::PointF(180.f, 180.f));
    {
      scoped_ptr<LayerImpl> grand_child3 =
              LayerImpl::Create(host_impl_.active_tree(), 6);
      grand_child3->SetPosition(gfx::PointF(240.f, 240.f));
      grand_child3->SetAnchorPoint(gfx::PointF());
      grand_child3->SetBounds(gfx::Size(10, 10));
      grand_child3->SetContentBounds(gfx::Size(10, 10));
      grand_child3->SetDrawsContent(true);
      child1->AddChild(grand_child3.Pass());
    }
    child1->SetOpacity(0.5f);
    EmulateDrawingOneFrame(root.get());
  
    // CASE 1: adding a reflection about the left edge of grand_child1.
    //
    ClearDamageForAllSurfaces(root.get());
    {
      scoped_ptr<LayerImpl> grand_child1_replica =
              LayerImpl::Create(host_impl_.active_tree(), 7);
      grand_child1_replica->SetPosition(gfx::PointF());
      grand_child1_replica->SetAnchorPoint(gfx::PointF());
      gfx::Transform reflection;
      reflection.Scale3d(-1.0, 1.0, 1.0);
      grand_child1_replica->SetTransform(reflection);
      grand_child1->SetReplicaLayer(grand_child1_replica.Pass());
    }
    EmulateDrawingOneFrame(root.get());
  
    gfx::RectF grand_child_damage_rect =
            grand_child1->render_surface()->damage_tracker()->
                current_damage_rect();
    gfx::RectF child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    // The grand_child surface damage should not include its own replica. The
    // child surface damage should include the normal and replica surfaces.
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 8.f), grand_child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(194.f, 200.f, 12.f, 8.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(294.f, 300.f, 12.f, 8.f), root_damage_rect);
  
    // CASE 2: moving the descendant surface should cause both the original and
    //         reflected areas to be damaged on the target.
    ClearDamageForAllSurfaces(root.get());
    gfx::Rect old_content_rect = child1->render_surface()->content_rect();
    grand_child1->SetPosition(gfx::PointF(195.f, 205.f));
    EmulateDrawingOneFrame(root.get());
    ASSERT_EQ(old_content_rect.width(),
              child1->render_surface()->content_rect().width());
    ASSERT_EQ(old_content_rect.height(),
              child1->render_surface()->content_rect().height());
  
    grand_child_damage_rect =
            grand_child1->render_surface()->
                damage_tracker()->current_damage_rect();
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    // The child surface damage should include normal and replica surfaces for
    // both old and new locations.
    //  - old location in target space: gfx::RectF(194.f, 200.f, 12.f, 8.f)
    //  - new location in target space: gfx::RectF(189.f, 205.f, 12.f, 8.f)
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 8.f), grand_child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(189.f, 200.f, 17.f, 13.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(289.f, 300.f, 17.f, 13.f), root_damage_rect);
  
    // CASE 3: removing the reflection should cause the entire region including
    //         reflection to damage the target surface.
    ClearDamageForAllSurfaces(root.get());
    grand_child1->SetReplicaLayer(scoped_ptr<LayerImpl>());
    EmulateDrawingOneFrame(root.get());
    ASSERT_EQ(old_content_rect.width(),
              child1->render_surface()->content_rect().width());
    ASSERT_EQ(old_content_rect.height(),
              child1->render_surface()->content_rect().height());
  
    EXPECT_FALSE(grand_child1->render_surface());
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
  
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(189.f, 205.f, 12.f, 8.f), child_damage_rect);
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(289.f, 305.f, 12.f, 8.f), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForMask) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    // In the current implementation of the damage tracker, changes to mask
    // layers should damage the entire corresponding surface.
  
    ClearDamageForAllSurfaces(root.get());
  
    // Set up the mask layer.
    {
      scoped_ptr<LayerImpl> mask_layer =
              LayerImpl::Create(host_impl_.active_tree(), 3);
      mask_layer->SetPosition(child->position());
      mask_layer->SetAnchorPoint(gfx::PointF());
      mask_layer->SetBounds(child->bounds());
      mask_layer->SetContentBounds(child->bounds());
      child->SetMaskLayer(mask_layer.Pass());
    }
    LayerImpl* mask_layer = child->mask_layer();
  
    // Add opacity and a grand_child so that the render surface persists even
    // after we remove the mask.
    child->SetOpacity(0.5f);
    {
      scoped_ptr<LayerImpl> grand_child =
              LayerImpl::Create(host_impl_.active_tree(), 4);
      grand_child->SetPosition(gfx::PointF(2.f, 2.f));
      grand_child->SetAnchorPoint(gfx::PointF());
      grand_child->SetBounds(gfx::Size(2, 2));
      grand_child->SetContentBounds(gfx::Size(2, 2));
      grand_child->SetDrawsContent(true);
      child->AddChild(grand_child.Pass());
    }
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that a new surface was created for the child.
    ASSERT_TRUE(child->render_surface());
  
    // CASE 1: the update_rect on a mask layer should damage the entire target
    //         surface.
    ClearDamageForAllSurfaces(root.get());
    mask_layer->SetUpdateRect(gfx::RectF(1.f, 2.f, 3.f, 4.f));
    EmulateDrawingOneFrame(root.get());
    gfx::RectF child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 30.f, 30.f), child_damage_rect);
  
    // CASE 2: a property change on the mask layer should damage the entire
    //         target surface.
  
    // Advance one frame without damage so that we know the damage rect is not
    // leftover from the previous case.
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(child_damage_rect.IsEmpty());
  
    // Then test the property change.
    ClearDamageForAllSurfaces(root.get());
    mask_layer->SetStackingOrderChanged(true);
  
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 30.f, 30.f), child_damage_rect);
  
    // CASE 3: removing the mask also damages the entire target surface.
    //
  
    // Advance one frame without damage so that we know the damage rect is not
    // leftover from the previous case.
    ClearDamageForAllSurfaces(root.get());
    EmulateDrawingOneFrame(root.get());
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(child_damage_rect.IsEmpty());
  
    // Then test mask removal.
    ClearDamageForAllSurfaces(root.get());
    child->SetMaskLayer(scoped_ptr<LayerImpl>());
    ASSERT_TRUE(child->LayerPropertyChanged());
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that a render surface still exists.
    ASSERT_TRUE(child->render_surface());
  
    child_damage_rect =
            child->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 30.f, 30.f), child_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    LayerImpl* grand_child1 = child1->children()[0];
  
    // Changes to a replica's mask should not damage the original surface,
    // because it is not masked. But it does damage the ancestor target surface.
  
    ClearDamageForAllSurfaces(root.get());
  
    // Create a reflection about the left edge of grand_child1.
    {
      scoped_ptr<LayerImpl> grand_child1_replica =
              LayerImpl::Create(host_impl_.active_tree(), 6);
      grand_child1_replica->SetPosition(gfx::PointF());
      grand_child1_replica->SetAnchorPoint(gfx::PointF());
      gfx::Transform reflection;
      reflection.Scale3d(-1.0, 1.0, 1.0);
      grand_child1_replica->SetTransform(reflection);
      grand_child1->SetReplicaLayer(grand_child1_replica.Pass());
    }
    LayerImpl* grand_child1_replica = grand_child1->replica_layer();
  
    // Set up the mask layer on the replica layer
    {
      scoped_ptr<LayerImpl> replica_mask_layer =
              LayerImpl::Create(host_impl_.active_tree(), 7);
      replica_mask_layer->SetPosition(gfx::PointF());
      replica_mask_layer->SetAnchorPoint(gfx::PointF());
      replica_mask_layer->SetBounds(grand_child1->bounds());
      replica_mask_layer->SetContentBounds(grand_child1->bounds());
      grand_child1_replica->SetMaskLayer(replica_mask_layer.Pass());
    }
    LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer();
  
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that the appropriate render surfaces were created
    ASSERT_TRUE(grand_child1->render_surface());
  
    // CASE 1: a property change on the mask should damage only the reflected
    //         region on the target surface.
    ClearDamageForAllSurfaces(root.get());
    replica_mask_layer->SetStackingOrderChanged(true);
    EmulateDrawingOneFrame(root.get());
  
    gfx::RectF grand_child_damage_rect =
            grand_child1->render_surface()->damage_tracker()->
                current_damage_rect();
    gfx::RectF child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
  
    EXPECT_TRUE(grand_child_damage_rect.IsEmpty());
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(194.f, 200.f, 6.f, 8.f), child_damage_rect);
  
    // CASE 2: removing the replica mask damages only the reflected region on the
    //         target surface.
    //
    ClearDamageForAllSurfaces(root.get());
    grand_child1_replica->SetMaskLayer(scoped_ptr<LayerImpl>());
    EmulateDrawingOneFrame(root.get());
  
    grand_child_damage_rect =
            grand_child1->render_surface()->damage_tracker()->
                current_damage_rect();
    child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
  
    EXPECT_TRUE(grand_child_damage_rect.IsEmpty());
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(194.f, 200.f, 6.f, 8.f), child_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithAnchor) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
    LayerImpl* child1 = root->children()[0];
    LayerImpl* grand_child1 = child1->children()[0];
  
    // Verify that the correct replica_origin_transform is used for the
    // replica_mask.
    ClearDamageForAllSurfaces(root.get());
  
    // This is not actually the anchor point being tested, but by convention its
    // expected to be the same as the replica's anchor point.
    grand_child1->SetAnchorPoint(gfx::PointF(1.f, 0.f));
  
    {
      scoped_ptr<LayerImpl> grand_child1_replica =
              LayerImpl::Create(host_impl_.active_tree(), 6);
      grand_child1_replica->SetPosition(gfx::PointF());
  
      // This is the anchor being tested.
      grand_child1_replica->SetAnchorPoint(gfx::PointF(1.f, 0.f));
      gfx::Transform reflection;
      reflection.Scale3d(-1.0, 1.0, 1.0);
      grand_child1_replica->SetTransform(reflection);
      grand_child1->SetReplicaLayer(grand_child1_replica.Pass());
    }
    LayerImpl* grand_child1_replica = grand_child1->replica_layer();
  
    // Set up the mask layer on the replica layer
    {
      scoped_ptr<LayerImpl> replica_mask_layer =
              LayerImpl::Create(host_impl_.active_tree(), 7);
      replica_mask_layer->SetPosition(gfx::PointF());
      // Note: this is not the anchor being tested.
      replica_mask_layer->SetAnchorPoint(gfx::PointF());
      replica_mask_layer->SetBounds(grand_child1->bounds());
      replica_mask_layer->SetContentBounds(grand_child1->bounds());
      grand_child1_replica->SetMaskLayer(replica_mask_layer.Pass());
    }
    LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer();
  
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check that the appropriate render surfaces were created
    ASSERT_TRUE(grand_child1->render_surface());
  
    // A property change on the replica_mask should damage the reflected region on
    // the target surface.
    ClearDamageForAllSurfaces(root.get());
    replica_mask_layer->SetStackingOrderChanged(true);
  
    EmulateDrawingOneFrame(root.get());
  
    gfx::RectF child_damage_rect =
            child1->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(206.f, 200.f, 6.f, 8.f), child_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, DamageWhenAddedExternally) {
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    // Case 1: This test ensures that when the tracker is given damage, that
    //         it is included with any other partial damage.
    //
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(10, 11, 12, 13));
    root->render_surface()->damage_tracker()->AddDamageNextUpdate(
        gfx::RectF(15, 16, 32, 33));
    EmulateDrawingOneFrame(root.get());
    gfx::RectF root_damage_rect =
        root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(
        gfx::UnionRects(gfx::RectF(15, 16, 32, 33),
                        gfx::RectF(100+10, 100+11, 12, 13)),
        root_damage_rect);
  
    // Case 2: An additional sanity check that adding damage works even when
    //         nothing on the layer tree changed.
    //
    ClearDamageForAllSurfaces(root.get());
    root->render_surface()->damage_tracker()->AddDamageNextUpdate(
        gfx::RectF(30, 31, 14, 15));
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
        root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(30, 31, 14, 15), root_damage_rect);
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
    // Though it should never happen, its a good idea to verify that the damage
    // tracker does not crash when it receives an empty layer_list.
  
    scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.active_tree(), 1);
    root->CreateRenderSurface();
  
    ASSERT_TRUE(root == root->render_target());
    RenderSurfaceImpl* target_surface = root->render_surface();
  
    LayerImplList empty_list;
    target_surface->damage_tracker()->UpdateDamageTrackingState(
        empty_list,
        target_surface->OwningLayerId(),
        false,
        gfx::Rect(),
        NULL,
        FilterOperations());
  
    gfx::RectF damage_rect =
            target_surface->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(damage_rect.IsEmpty());
  }
  
  TEST_F(DamageTrackerTest, VerifyDamageAccumulatesUntilReset) {
    // If damage is not cleared, it should accumulate.
  
    scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
    LayerImpl* child = root->children()[0];
  
    ClearDamageForAllSurfaces(root.get());
    child->SetUpdateRect(gfx::RectF(10.f, 11.f, 1.f, 2.f));
    EmulateDrawingOneFrame(root.get());
  
    // Sanity check damage after the first frame; this isnt the actual test yet.
    gfx::RectF root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(110.f, 111.f, 1.f, 2.f), root_damage_rect);
  
    // New damage, without having cleared the previous damage, should be unioned
    // to the previous one.
    child->SetUpdateRect(gfx::RectF(20.f, 25.f, 1.f, 2.f));
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_FLOAT_RECT_EQ(gfx::RectF(110.f, 111.f, 11.f, 16.f), root_damage_rect);
  
    // If we notify the damage tracker that we drew the damaged area, then damage
    // should be emptied.
    root->render_surface()->damage_tracker()->DidDrawDamagedArea();
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  
    // Damage should remain empty even after one frame, since there's yet no new
    // damage.
    EmulateDrawingOneFrame(root.get());
    root_damage_rect =
            root->render_surface()->damage_tracker()->current_damage_rect();
    EXPECT_TRUE(root_damage_rect.IsEmpty());
  }
  
  }  // namespace
  }  // namespace cc
  