Dirty rects always contain full tiles with delegated rendering.

cc/trees/layer_tree_host_unittest_damage.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 354 matching lines @@
       case 3:
         if (!delegating_renderer() &&
             !host_impl->settings().impl_side_painting) {
           // The update rect in the child should be damaged.
           // TODO(danakj): Remove this when impl side painting is always on.
           EXPECT_EQ(gfx::RectF(100+10, 100+11, 12, 13).ToString(),
                     root_damage.ToString());
         } else {
           // When using a delegating renderer, or using impl side painting, the
           // entire child is considered damaged as we need to replace its
-          // resources with newly created ones.
-          EXPECT_EQ(gfx::RectF(child_->position(), child_->bounds()).ToString(),
+          // resources with newly created ones. The damaged area is kept as it
+          // is, but entire child is painted.
+
+          // Verify damage area.

[danakj, 2013/12/02 15:09:49]

Instead of saying "Verify damage area" which is clear that's what you're doing,
you can say why you expect the damage area to be, or why. ie. "The damaged area
should match the invalidation exactly.

It looks like you could move the root_damage check out of this if/else statement
entirely, since it'll always be the same now. And just test the paint_rect in
the if/else (also add an if case to demonstrate the difference?)

+          EXPECT_EQ(gfx::RectF(100+10, 100+11, 12, 13).ToString(),
                     root_damage.ToString());
+          // Verify paint area.

[danakj, 2013/12/02 15:09:49]

Same here, say what you're expecting or why rather than just stating that you're
verifying something.

+          gfx::RectF paint_rect = static_cast<gfx::RectF>

[danakj, 2013/12/02 15:06:52]

You don't need to cast from Rect to RectF

+                                  (child_->Updater()->content_rect());
+          EXPECT_EQ((gfx::RectF(child_->bounds()).ToString()),

[danakj, 2013/12/02 15:06:52]

you don't need () around the RectF.ToString() call

+                    paint_rect.ToString());

[prashant.n, 2013/12/02 14:30:48]

Do we need this as we can verify with actual values?

+          paint_rect.set_origin(child_->position());
+          EXPECT_EQ(gfx::RectF(100, 100, 30, 30).ToString(),
+                    paint_rect.ToString());
+          EXPECT_FALSE(root_damage.Contains(paint_rect));

[prashant.n, 2013/12/02 14:30:48]

Should we verify this, as we have verified with actual values?
(100+10, 100+11, 12, 13) is inside (100, 100, 30, 30).

[danakj, 2013/12/02 15:06:52]

I think the above check against layer->bounds() is enough.

         }
         EXPECT_FALSE(frame_data->has_no_damage);
 
         // If we damage part of the frame, but also damage the full
         // frame, then the whole frame should be damaged.
         child_damage_rect_ = gfx::RectF(10, 11, 12, 13);
         host_impl->SetFullRootLayerDamage();
         break;
       case 4:
         // The whole frame is damaged.
@@ skipping 298 matching lines @@
   FakeContentLayerClient client_;
   int swap_count_;
   int prepare_to_draw_count_;
   int update_visible_tile_count_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws);
 
 }  // namespace
 }  // namespace cc