cc: Replace recorded region with direct map lookup

cc/resources/picture_pile.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/resources/picture_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 146 matching lines @@
     RenderingStatsInstrumentation* stats_instrumentation) {
   background_color_ = background_color;
   contents_opaque_ = contents_opaque;
 
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord,
       -kPixelDistanceToRecord);
+  recorded_viewport_ = interest_rect;
+  recorded_viewport_.Intersect(gfx::Rect(size()));
 
   bool invalidated = false;
   for (Region::Iterator i(invalidation); i.has_rect(); i.next()) {
     gfx::Rect invalidation = i.rect();
     // Split this inflated invalidation across tile boundaries and apply it
     // to all tiles that it touches.
     bool include_borders = true;
     for (TilingData::Iterator iter(&tiling_, invalidation, include_borders);
          iter;
          ++iter) {
@@ skipping 17 matching lines @@
     const PictureMapKey& key = it.index();
     PictureInfo& info = picture_map_[key];
 
     gfx::Rect rect = PaddedRect(key);
     int distance_to_visible =
         rect.ManhattanInternalDistance(visible_layer_rect);
 
     if (info.NeedsRecording(frame_number, distance_to_visible)) {
       gfx::Rect tile = tiling_.TileBounds(key.first, key.second);
       invalid_tiles.push_back(tile);
+    } else if (!info.GetPicture() && recorded_viewport_.Intersects(rect)) {
+      // Recorded viewport is just an optimization for a fully recorded
+      // interest rect.  In this case, a tile in that rect has declined
+      // to be recorded (probably due to frequent invalidations).
+      // TODO(enne): Shrink the recorded_viewport_ rather than clearing.
+      recorded_viewport_ = gfx::Rect();
     }
   }
 
   std::vector<gfx::Rect> record_rects;
   ClusterTiles(invalid_tiles, &record_rects);
 
-  if (record_rects.empty()) {
-    if (invalidated)
-      UpdateRecordedRegion();
+  if (record_rects.empty())
     return invalidated;
-  }
 
   for (std::vector<gfx::Rect>::iterator it = record_rects.begin();
        it != record_rects.end();
        it++) {
     gfx::Rect record_rect = *it;
     record_rect = PadRect(record_rect);
 
     int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
     scoped_refptr<Picture> picture;
     int num_raster_threads = RasterWorkerPool::GetNumRasterThreads();
@@ skipping 15 matching lines @@
                                   num_raster_threads);
         base::TimeDelta duration =
             stats_instrumentation->EndRecording(start_time);
         best_duration = std::min(duration, best_duration);
       }
       int recorded_pixel_count =
           picture->LayerRect().width() * picture->LayerRect().height();
       stats_instrumentation->AddRecord(best_duration, recorded_pixel_count);
     }
 
+    bool found_tile_for_recorded_picture = false;
+
     bool include_borders = true;
     for (TilingData::Iterator it(&tiling_, record_rect, include_borders); it;
          ++it) {
       const PictureMapKey& key = it.index();
       gfx::Rect tile = PaddedRect(key);
       if (record_rect.Contains(tile)) {
         PictureInfo& info = picture_map_[key];
         info.SetPicture(picture);
+        found_tile_for_recorded_picture = true;
       }
     }
+    DCHECK(found_tile_for_recorded_picture);
   }
 
-  UpdateRecordedRegion();
+  has_any_recordings_ = true;
+  DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 }  // namespace cc