cc: Add support for partial swaps when using impl-side painting.

cc/trees/damage_tracker.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 <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
@@ skipping 288 matching lines @@
     target_damage_rect->Union(old_rect_in_target_space);
   } else if (!layer->update_rect().IsEmpty()) {
     // If the layer properties haven't changed, then the the target surface is
     // only affected by the layer's update area, which could be empty.
     gfx::RectF update_content_rect =
         layer->LayerRectToContentRect(layer->update_rect());
     gfx::RectF update_rect_in_target_space =
         MathUtil::MapClippedRect(layer->draw_transform(), update_content_rect);
     target_damage_rect->Union(update_rect_in_target_space);
   }
+
+  if (!layer->initialized_tile_rect().IsEmpty()) {
+    gfx::RectF update_tile_rect_in_screen_space = MathUtil::MapClippedRect(
+        layer->screen_space_transform(), layer->initialized_tile_rect());

[reveman, 2014/04/11 18:11:34]

I think we should unite this with update_rect() by not looking at update_rect
above and instead required that damage to be added to the damage rect used for
tile invalidation.

[sohanjg, 2014/04/14 10:16:11]

Done.
ptal, i am uniting with layers' update_rect before tracking the damage area, so
that the existing logic is not affected.

+    current_damage_rect_.Union(update_tile_rect_in_screen_space);
+    layer->SetInitializedTileRect(gfx::Rect());

[reveman, 2014/04/11 18:11:34]

I don't think this is the right place to reset the damage rect? what if this is
called twice?

[sohanjg, 2014/04/14 10:16:11]

this will be called only when we calculate renderpass, once for each
preparetodraw.
Or its better to reset it after frame is drawn (DrawFrame()) ?

+  }
 }
 
 void DamageTracker::ExtendDamageForRenderSurface(
     LayerImpl* layer, gfx::RectF* target_damage_rect) {
   // There are two ways a "descendant surface" can damage regions of the "target
   // surface":
   //   1. Property change:
   //        - a surface's geometry can change because of
   //            - changes to descendants (i.e. the subtree) that affect the
   //              surface's content rect
@@ skipping 77 matching lines @@
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   if (layer->background_filters().HasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
                                           layer->background_filters());
   }
 }
 
 }  // namespace cc