cc: Ensure that large damage doesn't register as "frame has no damage"

cc/trees/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 "cc/trees/damage_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 69 matching lines @@
   }
 
   root->layer_tree_impl()->ResetAllChangeTracking();
 }
 
 class DamageTrackerTest : public testing::Test {
  public:
   DamageTrackerTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_) {}
 
-  LayerImpl* CreateTestTreeWithOneSurface() {
+  LayerImpl* CreateTestTreeWithOneSurface(int number_of_children) {
     host_impl_.active_tree()->DetachLayers();
     std::unique_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_.active_tree(), 1);
-    std::unique_ptr<LayerImpl> child =
-        LayerImpl::Create(host_impl_.active_tree(), 2);
 
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(500, 500));
     root->SetDrawsContent(true);
     root->test_properties()->force_render_surface = true;
 
-    child->SetPosition(gfx::PointF(100.f, 100.f));
-    child->SetBounds(gfx::Size(30, 30));
-    child->SetDrawsContent(true);
-    root->test_properties()->AddChild(std::move(child));
+    for (int i = 0; i < number_of_children; ++i) {
+      std::unique_ptr<LayerImpl> child =
+          LayerImpl::Create(host_impl_.active_tree(), 2 + i);
+      child->SetPosition(gfx::PointF(100.f, 100.f));
+      child->SetBounds(gfx::Size(30, 30));
+      child->SetDrawsContent(true);
+      root->test_properties()->AddChild(std::move(child));
+    }
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
 
     return host_impl_.active_tree()->root_layer_for_testing();
   }
 
   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.
 
@@ skipping 36 matching lines @@
 
     child1->test_properties()->AddChild(std::move(grand_child1));
     child1->test_properties()->AddChild(std::move(grand_child2));
     root->test_properties()->AddChild(std::move(child1));
     root->test_properties()->AddChild(std::move(child2));
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
 
     return host_impl_.active_tree()->root_layer_for_testing();
   }
 
-  LayerImpl* CreateAndSetUpTestTreeWithOneSurface() {
-    LayerImpl* root = CreateTestTreeWithOneSurface();
+  LayerImpl* CreateAndSetUpTestTreeWithOneSurface(int number_of_children = 1) {
+    LayerImpl* root = CreateTestTreeWithOneSurface(number_of_children);
 
     // Setup includes going past the first frame which always damages
     // everything, so that we can actually perform specific tests.
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
     EmulateDrawingOneFrame(root);
 
     return root;
   }
 
   LayerImpl* CreateAndSetUpTestTreeWithTwoSurfaces() {
@@ skipping 16 matching lines @@
 TEST_F(DamageTrackerTest, SanityCheckTestTreeWithOneSurface) {
   // Sanity check that the simple test tree will actually produce the expected
   // render surfaces and layer lists.
 
   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::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
 
   EXPECT_EQ(gfx::Rect(500, 500).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) {
   // Sanity check that the complex test tree will actually produce the expected
   // render surfaces and layer lists.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
 
   LayerImpl* child1 = root->test_properties()->children[0];
   LayerImpl* child2 = root->test_properties()->children[1];
-  gfx::Rect child_damage_rect =
-      child1->render_surface()->damage_tracker()->current_damage_rect();
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+
+  gfx::Rect child_damage_rect;
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_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_EQ(gfx::Rect(190, 190, 16, 18).ToString(),
             child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(500, 500).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // CASE 1: Setting the update rect should cause the corresponding damage to
   //         the surface.
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of update_rect (10, 11)
   // relative to the child (100, 100).
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(),
             root_damage_rect.ToString());
 
   // CASE 2: The same update rect twice in a row still produces the same
   //         damage.
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(),
             root_damage_rect.ToString());
 
   // CASE 3: Setting a different update rect should cause damage on the new
   //         update region, but no additional exposed old region.
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(20, 25, 1, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(120, 125, 1, 2).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerDamageRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // CASE 1: Adding the layer damage rect should cause the corresponding damage
   // to the surface.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(10, 11, 12, 13));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of layer damage_rect
   // (10, 11) relative to the child (100, 100).
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 12, 13)));
 
   // CASE 2: The same layer damage rect twice in a row still produces the same
   // damage.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(10, 11, 12, 13));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 12, 13)));
 
   // CASE 3: Adding a different layer damage rect should cause damage on the
   // new damaged region, but no additional exposed old region.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(20, 25, 1, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of layer damage_rect
   // (20, 25) relative to the child (100, 100).
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(120, 125, 1, 2)));
 
   // CASE 4: Adding multiple layer damage rects should cause a unified
   // damage on root damage rect.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(20, 25, 1, 2));
   child->AddDamageRect(gfx::Rect(10, 15, 3, 4));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of layer damage_rect
   // (20, 25) relative to the child (100, 100).
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(120, 125, 1, 2)));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 115, 3, 4)));
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerUpdateAndDamageRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // CASE 1: Adding the layer damage rect and update rect should cause the
   // corresponding damage to the surface.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(5, 6, 12, 13));
   child->SetUpdateRect(gfx::Rect(15, 16, 14, 10));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of unified layer
   // damage_rect and update rect (5, 6)
   // relative to the child (100, 100).
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 106, 24, 20)));
 
   // CASE 2: The same layer damage rect and update rect twice in a row still
   // produces the same damage.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(10, 11, 12, 13));
   child->SetUpdateRect(gfx::Rect(10, 11, 14, 15));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 14, 15)));
 
   // CASE 3: Adding a different layer damage rect and update rect should cause
   // damage on the new damaged region, but no additional exposed old region.
   ClearDamageForAllSurfaces(root);
   child->AddDamageRect(gfx::Rect(20, 25, 2, 3));
   child->SetUpdateRect(gfx::Rect(5, 10, 7, 8));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Damage position on the surface should be: position of unified layer damage
   // rect and update rect (5, 10) relative to the child (100, 100).
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 110, 17, 18)));
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // CASE 1: The layer's property changed flag takes priority over update rect.
   //
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.5f, child->effect_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
 
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
   // Damage should be the entire child layer in target_surface space.
   gfx::Rect expected_rect = gfx::Rect(100, 100, 30, 30);
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(expected_rect.ToString(), root_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Then, test the actual layer movement.
   ClearDamageForAllSurfaces(root);
   gfx::Transform translation;
   translation.Translate(100.f, 130.f);
   root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
       translation, child->transform_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
 
   // Expect damage to be the combination of the previous one and the new one.
   expected_rect.Union(gfx::Rect(200, 230, 30, 30));
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageWhenSurfaceRemoved) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* surface = root->test_properties()->children[0];
   LayerImpl* child = surface->test_properties()->children[0];
   child->SetDrawsContent(true);
   EmulateDrawingOneFrame(root);
   ClearDamageForAllSurfaces(root);
 
   surface->test_properties()->force_render_surface = false;
   child->SetDrawsContent(false);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(290, 290, 16, 18).ToString(),
             root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForTransformedLayer) {
   // If a layer is transformed, the damage rect should still enclose the entire
   // transformed layer.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
   child->test_properties()->force_render_surface = true;
 
   gfx::Transform rotation;
   rotation.Rotate(45.0);
 
   ClearDamageForAllSurfaces(root);
   child->test_properties()->transform_origin = gfx::Point3F(
       child->bounds().width() * 0.5f, child->bounds().height() * 0.5f, 0.f);
   child->SetPosition(gfx::PointF(85.f, 85.f));
   child->NoteLayerPropertyChanged();
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Sanity check that the layer actually moved to (85, 85), damaging its old
   // location and new location.
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(85, 85, 45, 45).ToString(), root_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
       rotation, child->transform_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
 
   // 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::Rect expected_rect = gfx::ToEnclosingRect(gfx::RectF(
       expected_position, expected_position, expected_width, expected_width));
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(expected_rect.ToString(), root_damage_rect.ToString());
 }
 
 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,
@@ skipping 31 matching lines @@
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.5f, child->effect_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
 
   // 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::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   gfx::Rect damage_we_care_about = gfx::Rect(gfx::Size(500, 500));
   EXPECT_TRUE(root_damage_rect.Contains(damage_we_care_about));
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* surface = root->test_properties()->children[0];
   LayerImpl* child = surface->test_properties()->children[0];
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(5.f));
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root);
   surface->test_properties()->filters = filters;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Setting the update rect should cause the corresponding damage to the
   // surface, blurred based on the size of the blur filter.
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(1, 2, 3, 4));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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
   // (15, since the blur radius is 5).
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(286, 287, 33, 34), root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForImageFilter) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
   gfx::Rect root_damage_rect, child_damage_rect;
 
   // Allow us to set damage on child too.
   child->SetDrawsContent(true);
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkBlurImageFilter::Make(2, 2, nullptr)));
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
       filters, child->effect_tree_index(), child->layer_tree_impl());
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-          child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   // gfx::Rect(100, 100, 30, 30), expanded by 6px for the 2px blur filter.
   EXPECT_EQ(gfx::Rect(94, 94, 42, 42), root_damage_rect);
 
   // gfx::Rect(0, 0, 30, 30), expanded by 6px for the 2px blur filter.
   EXPECT_EQ(gfx::Rect(-6, -6, 42, 42), child_damage_rect);
 
   // CASE 1: Setting the update rect should damage the whole surface (for now)
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(1, 1));
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-          child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   // gfx::Rect(100, 100, 1, 1), expanded by 6px for the 2px blur filter.
   EXPECT_EQ(gfx::Rect(94, 94, 13, 13), root_damage_rect);
 
   // gfx::Rect(0, 0, 1, 1), expanded by 6px for the 2px blur filter.
   EXPECT_EQ(gfx::Rect(-6, -6, 13, 13), child_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForTransformedImageFilter) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
@@ skipping 11 matching lines @@
   gfx::Transform transform;
   transform.RotateAboutYAxis(60);
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   child->test_properties()->transform = transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
       filters, child->effect_tree_index(), child->layer_tree_impl());
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-      child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   // Blur outset is 6px for a 2px blur.
   int blur_outset = 6;
   int rotated_outset_left = blur_outset / 2;
   int expected_rotated_width = (30 + 2 * blur_outset) / 2;
   gfx::Rect expected_root_damage(100 - rotated_outset_left, 100 - blur_outset,
                                  expected_rotated_width, 30 + 2 * blur_outset);
   expected_root_damage.Union(gfx::Rect(100, 100, 30, 30));
   EXPECT_EQ(expected_root_damage, root_damage_rect);
   EXPECT_EQ(gfx::Rect(-blur_outset, -blur_outset, 30 + 2 * blur_outset,
                       30 + 2 * blur_outset),
             child_damage_rect);
 
   // Setting the update rect should damage the whole surface (for now)
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(30, 30));
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-      child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   int expect_width = 30 + 2 * blur_outset;
   int expect_height = 30 + 2 * blur_outset;
   EXPECT_EQ(gfx::Rect(100 - blur_outset / 2, 100 - blur_outset,
                       expect_width / 2, expect_height),
             root_damage_rect);
   EXPECT_EQ(gfx::Rect(-blur_outset, -blur_outset, expect_width, expect_height),
             child_damage_rect);
 }
 
@@ skipping 10 matching lines @@
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root);
   child->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   int device_scale_factor = 2;
   EmulateDrawingOneFrame(root, device_scale_factor);
   child->layer_tree_impl()->property_trees()->effect_tree.OnFilterAnimated(
       filters, child->effect_tree_index(), child->layer_tree_impl());
   EmulateDrawingOneFrame(root, device_scale_factor);
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-      child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   // Blur outset is 9px for a 3px blur, scaled up by DSF.
   int blur_outset = 9 * device_scale_factor;
   gfx::Rect original_rect(100, 100, 100, 100);
   gfx::Rect expected_child_damage_rect(60, 60);
   expected_child_damage_rect.Inset(-blur_outset, -blur_outset);
   gfx::Rect expected_root_damage_rect(child_damage_rect);
   expected_root_damage_rect.Offset(200, 200);
   gfx::Rect expected_total_damage_rect = expected_root_damage_rect;
   expected_total_damage_rect.Union(original_rect);
   EXPECT_EQ(expected_total_damage_rect, root_damage_rect);
   EXPECT_EQ(expected_child_damage_rect, child_damage_rect);
 
   // Setting the update rect should damage only the affected area (original,
   // outset by 3 * blur sigma * DSF).
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(30, 30));
   EmulateDrawingOneFrame(root, device_scale_factor);
 
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
-  child_damage_rect =
-      child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
 
   EXPECT_EQ(expected_root_damage_rect, root_damage_rect);
   EXPECT_EQ(expected_child_damage_rect, child_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   LayerImpl* child2 = root->test_properties()->children[1];
 
@@ skipping 12 matching lines @@
 
   // 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. Note that child1's render surface has a size of
   //         206x208 due to contributions from grand_child1 and grand_child2.
   ClearDamageForAllSurfaces(root);
   root->SetUpdateRect(gfx::Rect(297, 297, 2, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_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::Rect expected_damage_rect = gfx::Rect(297, 297, 2, 2);
 
   // 6px spread for a 2px blur.
   expected_damage_rect.Inset(-6, -6, -6, -6);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // 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);
   root->SetUpdateRect(gfx::Rect(297, 297, 30, 30));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_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::Rect(297, 297, 30, 30);
 
   // 6px spread for a 2px blur.
   expected_damage_rect.Inset(-6, -6, 0, 0);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 3: Setting this update rect outside the blurred content_bounds of the
   //         blurred child1 will not cause it to be expanded.
   ClearDamageForAllSurfaces(root);
   root->SetUpdateRect(gfx::Rect(30, 30, 2, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   // Damage on the root should be: position of update_rect (30, 30), not
   // expanded.
   expected_damage_rect = gfx::Rect(30, 30, 2, 2);
 
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // 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);
   root->SetUpdateRect(gfx::Rect(99, 99, 1, 1));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   // Damage on the root should be: the originally damaged rect (99,99 1x1)
   // plus the rect that can influence with a 2px blur (93,93 13x13) intersected
   // with the surface rect (100,100 206x208). So no additional damage occurs
   // above or to the left, but there is additional damage within the blurred
   // area.
   expected_damage_rect = gfx::Rect(99, 99, 7, 7);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // 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);
   child2->SetUpdateRect(gfx::Rect(1, 1));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_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::Rect(11, 11, 1, 1);
 
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // 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);
   child1->SetUpdateRect(gfx::Rect(1, 1));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   // Damage on child1 should be: position of update_rect offset by the child's
   // position (100, 100), and expanded by the damage.
 
   // Damage should be (0,0 1x1), offset by the 100,100 offset of child1 in
   // root, and expanded 6px for the 2px blur (i.e., 94,94 13x13), but there
   // should be no damage outside child1 (i.e. none above or to the left of
   // 100,100.
   expected_damage_rect = gfx::Rect(100, 100, 7, 7);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 }
@@ skipping 13 matching lines @@
     child2->SetDrawsContent(true);
     root->test_properties()->AddChild(std::move(child2));
   }
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(400, 380, 6, 8).ToString(), root_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Then, test removing child1.
   root->test_properties()->RemoveChild(child1);
   child1 = NULL;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(),
             root_damage_rect.ToString());
 }
 
 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.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
 
@@ skipping 14 matching lines @@
     ASSERT_FALSE(child2_ptr->LayerPropertyChanged());
     ASSERT_TRUE(child2_ptr->update_rect().IsEmpty());
   }
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(400, 380, 6, 8).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child1 = root->test_properties()->children[0];
 
   // In this test we don't want the above tree manipulation to be considered
   // part of the same frame.
   ClearDamageForAllSurfaces(root);
@@ skipping 10 matching lines @@
   EmulateDrawingOneFrame(root);
 
   // Damaging two layers simultaneously should cause combined damage.
   // - child1 update rect in surface space: gfx::Rect(100, 100, 1, 2);
   // - child2 update rect in surface space: gfx::Rect(400, 380, 3, 4);
   ClearDamageForAllSurfaces(root);
   child1->SetUpdateRect(gfx::Rect(1, 2));
   child2->SetUpdateRect(gfx::Rect(3, 4));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(100, 100, 303, 284).ToString(),
             root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForNestedSurfaces) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   LayerImpl* child2 = root->test_properties()->children[1];
   LayerImpl* grand_child1 =
       root->test_properties()->children[0]->test_properties()->children[0];
   child2->test_properties()->force_render_surface = true;
   grand_child1->test_properties()->force_render_surface = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   // CASE 1: Damage to a descendant surface should propagate properly to
   //         ancestor surface.
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.5f, grand_child1->effect_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(300, 300, 6, 8).ToString(), root_damage_rect.ToString());
 
   // CASE 2: Same as previous case, but with additional damage elsewhere that
   //         should be properly unioned.
   // - child1 surface damage in root surface space:
   //   gfx::Rect(300, 300, 6, 8);
   // - child2 damage in root surface space:
   //   gfx::Rect(11, 11, 18, 18);
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.7f, grand_child1->effect_tree_index(), root->layer_tree_impl());
   root->layer_tree_impl()->property_trees()->effect_tree.OnOpacityAnimated(
       0.7f, child2->effect_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(11, 11, 295, 297).ToString(),
             root_damage_rect.ToString());
 }
 
 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.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   LayerImpl* grand_child1 =
       root->test_properties()->children[0]->test_properties()->children[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   ClearDamageForAllSurfaces(root);
   grand_child1->SetPosition(gfx::PointF(195.f, 205.f));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
 
   // The new surface bounds should be damaged entirely, even though only one of
   // the layers changed.
   EXPECT_EQ(gfx::Rect(190, 190, 11, 23).ToString(),
             child_damage_rect.ToString());
 
   // 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_EQ(gfx::Rect(290, 290, 16, 23).ToString(),
@@ skipping 16 matching lines @@
   LayerImpl* child1 = root->test_properties()->children[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   ClearDamageForAllSurfaces(root);
   gfx::Transform translation;
   translation.Translate(-50.f, -50.f);
   root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
       translation, child1->transform_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
 
   // The new surface bounds should be damaged entirely.
   EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(),
             child_damage_rect.ToString());
 
   // The entire child1 surface and the old exposed child1 surface should damage
   // the root surface.
   //  - old child1 surface in target space: gfx::Rect(290, 290, 16, 18)
   //  - new child1 surface in target space: gfx::Rect(240, 240, 16, 18)
   EXPECT_EQ(gfx::Rect(240, 240, 66, 68).ToString(),
@@ skipping 10 matching lines @@
   //         exposed.
   ClearDamageForAllSurfaces(root);
   child1->test_properties()->force_render_surface = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(290, 290, 16, 18).ToString(),
             root_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Then change the tree so that the render surface is added back.
   ClearDamageForAllSurfaces(root);
   child1->test_properties()->force_render_surface = true;
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(),
             child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(290, 290, 16, 18).ToString(),
             root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyNoDamageWhenNothingChanged) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   // CASE 1: If nothing changes, the damage rect should be empty.
   //
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(child_damage_rect.IsEmpty());
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
   gfx::Rect child_damage_rect;
   gfx::Rect 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);
   child1->SetUpdateRect(gfx::Rect(1, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child1->render_surface()->damage_tracker()->current_damage_rect();
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(child_damage_rect.IsEmpty());
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForMask) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   // In the current implementation of the damage tracker, changes to mask
   // layers should damage the entire corresponding surface.
@@ skipping 23 matching lines @@
   }
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // CASE 1: the update_rect on a mask layer should damage the entire target
   //         surface.
   ClearDamageForAllSurfaces(root);
   mask_layer->SetUpdateRect(gfx::Rect(1, 2, 3, 4));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  gfx::Rect child_damage_rect =
-      child->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect child_damage_rect;
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
   EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
   EXPECT_TRUE(child_damage_rect.IsEmpty());
 
   // Then test the property change.
   ClearDamageForAllSurfaces(root);
   mask_layer->NoteLayerPropertyChanged();
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
   EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString());
 
   // 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);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  child_damage_rect =
-          child->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
   EXPECT_TRUE(child_damage_rect.IsEmpty());
 
   // Then test mask removal.
   ClearDamageForAllSurfaces(root);
   child->test_properties()->SetMaskLayer(nullptr);
   child->NoteLayerPropertyChanged();
   ASSERT_TRUE(child->LayerPropertyChanged());
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // 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_TRUE(child->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &child_damage_rect));
   EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, DamageWhenAddedExternally) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->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);
   child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   root->render_surface()->damage_tracker()->AddDamageNextUpdate(
       gfx::Rect(15, 16, 32, 33));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::UnionRects(gfx::Rect(15, 16, 32, 33),
                             gfx::Rect(100 + 10, 100 + 11, 12, 13)).ToString(),
             root_damage_rect.ToString());
 
   // Case 2: An additional sanity check that adding damage works even when
   //         nothing on the layer tree changed.
   //
   ClearDamageForAllSurfaces(root);
   root->render_surface()->damage_tracker()->AddDamageNextUpdate(
       gfx::Rect(30, 31, 14, 15));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(30, 31, 14, 15).ToString(), root_damage_rect.ToString());
 }
 
 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.
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
   LayerImpl* root_ptr = host_impl_.active_tree()->root_layer_for_testing();
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root_ptr);
 
   DCHECK_EQ(root_ptr->render_surface(), root_ptr->render_target());
   RenderSurfaceImpl* target_surface = root_ptr->render_surface();
 
   LayerImplList empty_list;
   target_surface->damage_tracker()->UpdateDamageTrackingState(
       empty_list, target_surface, false, gfx::Rect(), NULL, FilterOperations());
 
-  gfx::Rect damage_rect =
-      target_surface->damage_tracker()->current_damage_rect();
+  gfx::Rect damage_rect;
+  EXPECT_TRUE(
+      target_surface->damage_tracker()->GetDamageRectIfValid(&damage_rect));
   EXPECT_TRUE(damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageAccumulatesUntilReset) {
   // If damage is not cleared, it should accumulate.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->test_properties()->children[0];
 
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10.f, 11.f, 1.f, 2.f));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
   // Sanity check damage after the first frame; this isnt the actual test yet.
-  gfx::Rect root_damage_rect =
-      root->render_surface()->damage_tracker()->current_damage_rect();
+  gfx::Rect root_damage_rect;
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(110, 111, 1, 2).ToString(), root_damage_rect.ToString());
 
   // New damage, without having cleared the previous damage, should be unioned
   // to the previous one.
   child->SetUpdateRect(gfx::Rect(20, 25, 1, 2));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_EQ(gfx::Rect(110, 111, 11, 16).ToString(),
             root_damage_rect.ToString());
 
   // 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->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Damage should remain empty even after one frame, since there's yet no new
   // damage.
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
-  root_damage_rect =
-          root->render_surface()->damage_tracker()->current_damage_rect();
+  EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &root_damage_rect));
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, HugeDamageRect) {
   // This number is so large that we start losting floating point accuracy.
   const int kBigNumber = 900000000;
   // Walk over a range to find floating point inaccuracy boundaries that move
   // toward the wrong direction.
   const int kRange = 5000;
 
@@ skipping 13 matching lines @@
     float device_scale_factor = 1.f;
     // Visible rects computed from combining clips in target space and root
     // space don't match because of the loss in floating point accuracy. So, we
     // skip verify_clip_tree_calculations.
     bool skip_verify_visible_rect_calculations = true;
     EmulateDrawingOneFrame(root, device_scale_factor,
                            skip_verify_visible_rect_calculations);
 
     // The expected damage should cover the visible part of the child layer,
     // which is (0, 0, i, i) in the viewport.
-    gfx::Rect root_damage_rect =
-        root->render_surface()->damage_tracker()->current_damage_rect();
+    gfx::Rect root_damage_rect;
+    EXPECT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+        &root_damage_rect));
     gfx::Rect damage_we_care_about = gfx::Rect(i, i);
     EXPECT_LE(damage_we_care_about.right(), root_damage_rect.right());
     EXPECT_LE(damage_we_care_about.bottom(), root_damage_rect.bottom());
   }
 }
 
+TEST_F(DamageTrackerTest, DamageRectTooBig) {
+  LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface(2);
+  LayerImpl* child1 = root->test_properties()->children[0];
+  LayerImpl* child2 = root->test_properties()->children[1];
+
+  // Really far left.
+  child1->SetPosition(gfx::PointF(std::numeric_limits<int>::min() + 100, 0));
+  child1->SetBounds(gfx::Size(1, 1));
+
+  // Really far right.
+  child2->SetPosition(gfx::PointF(std::numeric_limits<int>::max() - 100, 0));
+  child2->SetBounds(gfx::Size(1, 1));
+
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  float device_scale_factor = 1.f;
+  bool skip_verify_visible_rect_calculations = true;
+  EmulateDrawingOneFrame(root, device_scale_factor,
+                         skip_verify_visible_rect_calculations);
+
+  // The expected damage would be too large to store in a gfx::Rect, so we
+  // should damage everything (ie, we don't have a valid rect).
+  gfx::Rect damage_rect;
+  EXPECT_FALSE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(root->render_surface()->content_rect(),
+            root->render_surface()->GetDamageRect());
+}
+
+TEST_F(DamageTrackerTest, DamageRectTooBigWithFilter) {
+  LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface(2);
+  LayerImpl* child1 = root->test_properties()->children[0];
+  LayerImpl* child2 = root->test_properties()->children[1];
+
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateBlurFilter(5.f));
+  root->SetDrawsContent(true);
+  root->test_properties()->background_filters = filters;
+
+  // Really far left.
+  child1->SetPosition(gfx::PointF(std::numeric_limits<int>::min() + 100, 0));
+  child1->SetBounds(gfx::Size(1, 1));
+
+  // Really far right.
+  child2->SetPosition(gfx::PointF(std::numeric_limits<int>::max() - 100, 0));
+  child2->SetBounds(gfx::Size(1, 1));
+
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  float device_scale_factor = 1.f;
+  bool skip_verify_visible_rect_calculations = true;
+  EmulateDrawingOneFrame(root, device_scale_factor,
+                         skip_verify_visible_rect_calculations);
+
+  // The expected damage would be too large to store in a gfx::Rect, so we
+  // should damage everything (ie, we don't have a valid rect).
+  gfx::Rect damage_rect;
+  EXPECT_FALSE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(root->render_surface()->content_rect(),
+            root->render_surface()->GetDamageRect());
+}
+
+TEST_F(DamageTrackerTest, DamageRectTooBigInRenderSurface) {
+  LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
+  LayerImpl* child1 = root->test_properties()->children[0];
+  LayerImpl* grandchild1 = child1->test_properties()->children[0];
+  LayerImpl* grandchild2 = child1->test_properties()->children[1];
+
+  // Really far left.
+  grandchild1->SetPosition(
+      gfx::PointF(std::numeric_limits<int>::min() + 500, 0));
+  grandchild1->SetBounds(gfx::Size(1, 1));
+  grandchild1->SetDrawsContent(true);
+
+  // Really far right.
+  grandchild2->SetPosition(
+      gfx::PointF(std::numeric_limits<int>::max() - 500, 0));
+  grandchild2->SetBounds(gfx::Size(1, 1));
+  grandchild2->SetDrawsContent(true);
+
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  float device_scale_factor = 1.f;
+  bool skip_verify_visible_rect_calculations = true;
+  LayerImplList render_surface_layer_list;
+  ExecuteCalculateDrawProperties(root, device_scale_factor,
+                                 skip_verify_visible_rect_calculations,
+                                 &render_surface_layer_list);
+
+  auto* surface = child1->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+  surface = root->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+
+  // The expected damage would be too large to store in a gfx::Rect, so we
+  // should damage everything on child1.
+  gfx::Rect damage_rect;
+  EXPECT_FALSE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(child1->render_surface()->content_rect(),
+            child1->render_surface()->GetDamageRect());
+
+  // However, the root should just use the child1 render surface's content rect
+  // as damage.
+  ASSERT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_TRUE(damage_rect.Contains(root->render_surface()->content_rect()));
+  EXPECT_TRUE(damage_rect.Contains(
+      gfx::ToEnclosingRect(child1->render_surface()->DrawableContentRect())));
+  EXPECT_EQ(damage_rect, root->render_surface()->GetDamageRect());
+
+  // Add new damage, without changing properties, which goes down a different
+  // path in the damage tracker.
+  root->layer_tree_impl()->ResetAllChangeTracking();
+  grandchild1->AddDamageRect(gfx::Rect(grandchild1->bounds()));
+  grandchild2->AddDamageRect(gfx::Rect(grandchild1->bounds()));
+
+  // Recompute all damage / properties.
+  render_surface_layer_list.clear();
+  ExecuteCalculateDrawProperties(root, device_scale_factor,
+                                 skip_verify_visible_rect_calculations,
+                                 &render_surface_layer_list);
+  surface = child1->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+  surface = root->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+
+  // Child1 should still not have a valid rect, since the union of the damage of
+  // its children is not representable by a single rect.
+  EXPECT_FALSE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(child1->render_surface()->content_rect(),
+            child1->render_surface()->GetDamageRect());
+
+  // Root should have valid damage and contain both its content rect and the
+  // drawable content rect of child1.
+  ASSERT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_TRUE(damage_rect.Contains(root->render_surface()->content_rect()));
+  EXPECT_TRUE(damage_rect.Contains(
+      gfx::ToEnclosingRect(child1->render_surface()->DrawableContentRect())));
+  EXPECT_EQ(damage_rect, root->render_surface()->GetDamageRect());
+}
+
+TEST_F(DamageTrackerTest, DamageRectTooBigInRenderSurfaceWithFilter) {
+  LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
+  LayerImpl* child1 = root->test_properties()->children[0];
+  LayerImpl* grandchild1 = child1->test_properties()->children[0];
+  LayerImpl* grandchild2 = child1->test_properties()->children[1];
+
+  // Set up a moving pixels filter on the child.
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateBlurFilter(5.f));
+  child1->SetDrawsContent(true);
+  child1->test_properties()->background_filters = filters;
+
+  // Really far left.
+  grandchild1->SetPosition(
+      gfx::PointF(std::numeric_limits<int>::min() + 500, 0));
+  grandchild1->SetBounds(gfx::Size(1, 1));
+  grandchild1->SetDrawsContent(true);
+
+  // Really far right.
+  grandchild2->SetPosition(
+      gfx::PointF(std::numeric_limits<int>::max() - 500, 0));
+  grandchild2->SetBounds(gfx::Size(1, 1));
+  grandchild2->SetDrawsContent(true);
+
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  float device_scale_factor = 1.f;
+  bool skip_verify_visible_rect_calculations = true;
+  LayerImplList render_surface_layer_list;
+  ExecuteCalculateDrawProperties(root, device_scale_factor,
+                                 skip_verify_visible_rect_calculations,
+                                 &render_surface_layer_list);
+
+  auto* surface = child1->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+  surface = root->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+
+  // The expected damage would be too large to store in a gfx::Rect, so we
+  // should damage everything on child1.
+  gfx::Rect damage_rect;
+  EXPECT_FALSE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(child1->render_surface()->content_rect(),
+            child1->render_surface()->GetDamageRect());
+
+  // However, the root should just use the child1 render surface's content rect
+  // as damage.
+  ASSERT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_TRUE(damage_rect.Contains(root->render_surface()->content_rect()));
+  EXPECT_TRUE(damage_rect.Contains(
+      gfx::ToEnclosingRect(child1->render_surface()->DrawableContentRect())));
+  EXPECT_EQ(damage_rect, root->render_surface()->GetDamageRect());
+
+  // Add new damage, without changing properties, which goes down a different
+  // path in the damage tracker.
+  root->layer_tree_impl()->ResetAllChangeTracking();
+  grandchild1->AddDamageRect(gfx::Rect(grandchild1->bounds()));
+  grandchild2->AddDamageRect(gfx::Rect(grandchild1->bounds()));
+
+  // Recompute all damage / properties.
+  render_surface_layer_list.clear();
+  ExecuteCalculateDrawProperties(root, device_scale_factor,
+                                 skip_verify_visible_rect_calculations,
+                                 &render_surface_layer_list);
+  surface = child1->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+  surface = root->render_surface();
+  surface->damage_tracker()->UpdateDamageTrackingState(
+      surface->layer_list(), surface, false, surface->content_rect(),
+      surface->MaskLayer(), surface->Filters());
+
+  // Child1 should still not have a valid rect, since the union of the damage of
+  // its children is not representable by a single rect.
+  EXPECT_FALSE(child1->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_EQ(child1->render_surface()->content_rect(),
+            child1->render_surface()->GetDamageRect());
+
+  // Root should have valid damage and contain both its content rect and the
+  // drawable content rect of child1.
+  ASSERT_TRUE(root->render_surface()->damage_tracker()->GetDamageRectIfValid(
+      &damage_rect));
+  EXPECT_TRUE(damage_rect.Contains(root->render_surface()->content_rect()));
+  EXPECT_TRUE(damage_rect.Contains(
+      gfx::ToEnclosingRect(child1->render_surface()->DrawableContentRect())));
+  EXPECT_EQ(damage_rect, root->render_surface()->GetDamageRect());
+}
+
 }  // namespace
 }  // namespace cc