Dirty rects always contain full tiles with delegated rendering.

cc/layers/tiled_layer.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/layers/tiled_layer.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 316 matching lines @@
                              const OcclusionTracker* occlusion,
                              bool* updated) {
   CreateUpdaterIfNeeded();
 
   bool ignore_occlusions = !occlusion;
   if (!HaveTexturesForTiles(left, top, right, bottom, ignore_occlusions)) {
     failed_update_ = true;
     return false;
   }
 
-  gfx::Rect paint_rect =
-      MarkTilesForUpdate(left, top, right, bottom, ignore_occlusions);
+  gfx::Rect update_rect;
+  gfx::Rect paint_rect;
+  MarkTilesForUpdate(
+    &update_rect, &paint_rect, left, top, right, bottom, ignore_occlusions);
 
   if (occlusion)
     occlusion->overdraw_metrics()->DidPaint(paint_rect);
 
   if (paint_rect.IsEmpty())
     return true;
 
   *updated = true;
   UpdateTileTextures(
-      paint_rect, left, top, right, bottom, queue, occlusion);
+      update_rect, paint_rect, left, top, right, bottom, queue, occlusion);
   return true;
 }
 
 void TiledLayer::MarkOcclusionsAndRequestTextures(
     int left,
     int top,
     int right,
     int bottom,
     const OcclusionTracker* occlusion) {
   // There is some difficult dependancies between occlusions, recording
@@ skipping 56 matching lines @@
       if (tile->occluded && !ignore_occlusions)
         continue;
 
       if (!tile->managed_resource()->can_acquire_backing_texture())
         return false;
     }
   }
   return true;
 }
 
-gfx::Rect TiledLayer::MarkTilesForUpdate(int left,
-                                         int top,
-                                         int right,
-                                         int bottom,
-                                         bool ignore_occlusions) {
-  gfx::Rect paint_rect;
+void TiledLayer::MarkTilesForUpdate(gfx::Rect* update_rect,
+                                    gfx::Rect* paint_rect,
+                                    int left,
+                                    int top,
+                                    int right,
+                                    int bottom,
+                                    bool ignore_occlusions) {
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
                      // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
       if (tile->occluded && !ignore_occlusions)
         continue;
+
+      // Prepare update rect from original dirty rects
+      update_rect->Union(tile->dirty_rect);
+
       // TODO(reveman): Decide if partial update should be allowed based on cost
       // of update. https://bugs.webkit.org/show_bug.cgi?id=77376
       if (tile->is_dirty() &&
           !layer_tree_host()->AlwaysUsePartialTextureUpdates()) {
         // If we get a partial update, we use the same texture, otherwise return
         // the current texture backing, so we don't update visible textures
         // non-atomically.  If the current backing is in-use, it won't be
         // deleted until after the commit as the texture manager will not allow
         // deletion or recycling of in-use textures.
         if (TileOnlyNeedsPartialUpdate(tile) &&
             layer_tree_host()->RequestPartialTextureUpdate()) {
           tile->partial_update = true;
         } else {
           tile->dirty_rect = tiler_->TileRect(tile);
           tile->managed_resource()->ReturnBackingTexture();
         }
       }
 
-      paint_rect.Union(tile->dirty_rect);
+      paint_rect->Union(tile->dirty_rect);
       tile->MarkForUpdate();
     }
   }
-  return paint_rect;
 }
 
-void TiledLayer::UpdateTileTextures(gfx::Rect paint_rect,
+void TiledLayer::UpdateTileTextures(gfx::Rect update_rect,
+                                    gfx::Rect paint_rect,
                                     int left,
                                     int top,
                                     int right,
                                     int bottom,
                                     ResourceUpdateQueue* queue,
                                     const OcclusionTracker* occlusion) {
   // The update_rect should be in layer space. So we have to convert the
   // paint_rect from content space to layer space.
   float width_scale =
       paint_properties().bounds.width() /
       static_cast<float>(content_bounds().width());
   float height_scale =
       paint_properties().bounds.height() /
       static_cast<float>(content_bounds().height());
-  update_rect_ = gfx::ScaleRect(paint_rect, width_scale, height_scale);
+  update_rect_ = gfx::ScaleRect(update_rect, width_scale, height_scale);
 
-  // Calling PrepareToUpdate() calls into WebKit to paint, which may have the
-  // side effect of disabling compositing, which causes our reference to the
-  // texture updater to be deleted.  However, we can't free the memory backing
-  // the SkCanvas until the paint finishes, so we grab a local reference here to
-  // hold the updater alive until the paint completes.
-  scoped_refptr<LayerUpdater> protector(Updater());
   gfx::Rect painted_opaque_rect;
-  Updater()->PrepareToUpdate(paint_rect,
-                             tiler_->tile_size(),
-                             1.f / width_scale,
-                             1.f / height_scale,
-                             &painted_opaque_rect);
+  if (!update_rect.IsEmpty()) {

[enne (OOO), 2013/11/25 20:59:48]

I'm not sure this can ever happen.  I'd prefer a DCHECK to a conditional.

[prashant.n, 2013/11/26 04:56:06]

Yes, true, this will never happen. I'll remove this.

+    // Calling PrepareToUpdate() calls into WebKit to paint, which may have the
+    // side effect of disabling compositing, which causes our reference to the
+    // texture updater to be deleted.  However, we can't free the memory backing
+    // the SkCanvas until the paint finishes, so we grab a local reference here
+    // to hold the updater alive until the paint completes.
+    scoped_refptr<LayerUpdater> protector(Updater());
+    Updater()->PrepareToUpdate(update_rect,

[enne (OOO), 2013/11/25 20:59:48]

Re: point #2, I think this is wrong.  You need the entire paint rect.  Tiles
that can't be partially updated need to be entirely rastered and uploaded.

[prashant.n, 2013/11/26 04:56:06]

In TiledLayer::TileOnlyNeedsPartialUpdate(), we check two things -
1. whether dirty rect is partial
2. tile has the backing texture.

Can there be the case in delegate rendering, where tile has the backing texture
and there we could have updated only original dirty rect?

[danakj, 2013/11/26 16:08:39]

I agree, it should only be the update_rect_ that changes in this CL. The
painting should not change.

+                               paint_rect,
+                               tiler_->tile_size(),
+                               1.f / width_scale,
+                               1.f / height_scale,
+                               &painted_opaque_rect);
+  }
 
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       UpdatableTile* tile = TileAt(i, j);
       DCHECK(tile);  // Did SetTexturePriorites get skipped?
                      // TODO(enne): This should not ever be null.
       if (!tile)
         continue;
 
       gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
@@ skipping 400 matching lines @@
   gfx::Rect prepaint_rect = visible_content_rect();
   prepaint_rect.Inset(-tiler_->tile_size().width() * kPrepaintColumns,
                       -tiler_->tile_size().height() * kPrepaintRows);
   gfx::Rect content_rect(content_bounds());
   prepaint_rect.Intersect(content_rect);
 
   return prepaint_rect;
 }
 
 }  // namespace cc