cc: Indicate that we've updated a tiling if we invalidated it.

cc/tiles/picture_layer_tiling.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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 56 matching lines @@
       raster_source_(raster_source),
       resolution_(NON_IDEAL_RESOLUTION),
       may_contain_low_resolution_tiles_(false),
       tiling_data_(gfx::Size(), gfx::Size(), kBorderTexels),
       can_require_tiles_for_activation_(false),
       current_content_to_screen_scale_(0.f),
       has_visible_rect_tiles_(false),
       has_skewport_rect_tiles_(false),
       has_soon_border_rect_tiles_(false),
       has_eventually_rect_tiles_(false),
-      all_tiles_done_(true) {
+      all_tiles_done_(true),
+      invalidated_since_last_compute_priority_rects_(false) {
   DCHECK(!raster_source->IsSolidColor());
   gfx::Size content_bounds =
       gfx::ScaleToCeiledSize(raster_source_->GetSize(), contents_scale);
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   DCHECK(!gfx::ScaleToFlooredSize(raster_source_->GetSize(), contents_scale)
               .IsEmpty())
       << "Tiling created with scale too small as contents become empty."
       << " Layer bounds: " << raster_source_->GetSize().ToString()
       << " Contents scale: " << contents_scale;
@@ skipping 192 matching lines @@
     for (int i = before_left; i <= before_right; ++i) {
       Tile::CreateInfo info = CreateInfoForTile(i, after_bottom);
       if (ShouldCreateTileAt(info))
         CreateTile(info);
     }
   }
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
   DCHECK(tree_ != ACTIVE_TREE || !client_->GetPendingOrActiveTwinTiling(this));
+  invalidated_since_last_compute_priority_rects_ = true;
   RemoveTilesInRegion(layer_invalidation, true /* recreate tiles */);
 }
 
 void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
                                              bool recreate_tiles) {
   // We only invalidate the active tiling when it's orphaned: it has no pending
   // twin, so it's slated for removal in the future.
   if (live_tiles_rect_.IsEmpty())
     return;
   // Pick 16 for the size of the SmallMap before it promotes to a unordered_map.
@@ skipping 331 matching lines @@
     float ideal_contents_scale,
     double current_frame_time_in_seconds,
     const Occlusion& occlusion_in_layer_space) {
   // If we have, or had occlusions, mark the tiles as 'not done' to ensure that
   // we reiterate the tiles for rasterization.
   if (occlusion_in_layer_space.HasOcclusion() ||
       current_occlusion_in_layer_space_.HasOcclusion()) {
     set_all_tiles_done(false);
   }
 
+  bool invalidated = invalidated_since_last_compute_priority_rects_;
+  invalidated_since_last_compute_priority_rects_ = false;
   if (!NeedsUpdateForFrameAtTimeAndViewport(current_frame_time_in_seconds,
                                             viewport_in_layer_space)) {
     // This should never be zero for the purposes of has_ever_been_updated().
     DCHECK_NE(current_frame_time_in_seconds, 0.0);
-    return false;
+    return invalidated;
   }
 
   const float content_to_screen_scale = ideal_contents_scale / contents_scale_;
 
   // We want to compute the visible rect and eventually rect from it in the
   // space of the tiling. But the visible rect (viewport) can be arbitrarily
   // positioned, so be careful when scaling it since we can exceed integer
   // bounds.
   gfx::Rect eventually_rect;
   gfx::Rect visible_rect_in_content_space;
@@ skipping 373 matching lines @@
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc