cc: Start using raster/eviction iterators.

cc/resources/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_RESOURCES_PICTURE_LAYER_TILING_H_
 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
 
 #include <utility>
 #include <vector>
 
@@ skipping 23 matching lines @@
     const gfx::Rect& content_rect) = 0;
   virtual PicturePileImpl* GetPile() = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
   virtual const Region* GetInvalidation() = 0;
   virtual const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const = 0;
   virtual size_t GetMaxTilesForInterestArea() const = 0;
   virtual float GetSkewportTargetTimeInSeconds() const = 0;
   virtual int GetSkewportExtrapolationLimitInContentPixels() const = 0;
+  virtual WhichTree GetTree() const = 0;
+  virtual bool RequiresHighResToDraw() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   class CC_EXPORT TilingRasterTileIterator {
    public:
     TilingRasterTileIterator();
@@ skipping 12 matching lines @@
         return tiling_->tiling_data_.TileBounds(visible_iterator_.index_x(),
                                                 visible_iterator_.index_y());
       }
       return tiling_->tiling_data_.TileBounds(spiral_iterator_.index_x(),
                                               spiral_iterator_.index_y());
     }
 
    private:
     void AdvancePhase();
     bool TileNeedsRaster(Tile* tile) const {
+      if (tile->is_occluded())
+        return false;
       RasterMode mode = tile->DetermineRasterModeForTree(tree_);
       return tile->NeedsRasterForMode(mode);
     }
 
     PictureLayerTiling* tiling_;
 
     TilePriority::PriorityBin type_;
     gfx::Rect visible_rect_in_content_space_;
     gfx::Rect skewport_in_content_space_;
     gfx::Rect eventually_rect_in_content_space_;
@@ skipping 36 matching lines @@
   ~PictureLayerTiling();
 
   // Create a tiling with no tiles.  CreateTiles must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client);
   gfx::Size layer_bounds() const { return layer_bounds_; }
   void SetLayerBounds(const gfx::Size& layer_bounds);
   void Invalidate(const Region& layer_region);
-  void RemoveTilesInRegion(const Region& layer_region);
-  void CreateMissingTilesInLiveTilesRect();
 
   void SetClient(PictureLayerTilingClient* client);
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
 
   gfx::Rect TilingRect() const;
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
   float contents_scale() const { return contents_scale_; }
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
     return (iter == tiles_.end()) ? NULL : iter->second.get();
   }
 
+  Tile* GetOrCreateTileAt(int i, int j);
+
+  void CreateInterestRectTilesForTesting() {
+    for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_, true); iter;
+         ++iter) {
+      Tile* tile = GetOrCreateTileAt(iter.index_x(), iter.index_y());
+      if (tile) {
+        UpdateTileOcclusion(tile);
+        SetTilePriority(tile, true);
+      }
+    }
+  }
+
   void CreateAllTilesForTesting() {
     SetLiveTilesRect(tiling_data_.tiling_rect());
+    for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_, true); iter;
+         ++iter) {
+      Tile* tile = GetOrCreateTileAt(iter.index_x(), iter.index_y());
+      if (tile) {
+        UpdateTileOcclusion(tile);
+        SetTilePriority(tile, true);
+      }
+    }
   }
 
   std::vector<Tile*> AllTilesForTesting() const {
     std::vector<Tile*> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin();
          it != tiles_.end(); ++it)
       all_tiles.push_back(it->second.get());
     return all_tiles;
   }
 
@@ skipping 55 matching lines @@
       double current_frame_time_in_seconds,
       const OcclusionTracker<LayerImpl>* occlusion_tracker,
       const LayerImpl* render_target,
       const gfx::Transform& draw_transform);
 
   // Copies the src_tree priority into the dst_tree priority for all tiles.
   // The src_tree priority is reset to the lowest priority possible.  This
   // also updates the pile on each tile to be the current client's pile.
   void DidBecomeActive();
 
-  // Resets the active priority for all tiles in a tiling, when an active
-  // tiling is becoming recycled. This may include some tiles which are
-  // not in the the pending tiling (due to invalidations). This must
-  // be called before DidBecomeActive, as it resets the active priority
-  // while DidBecomeActive promotes pending priority on a similar set of tiles.
-  void DidBecomeRecycled();
-
   void UpdateTilesToCurrentPile();
 
   bool NeedsUpdateForFrameAtTime(double frame_time_in_seconds) {
     return frame_time_in_seconds != last_impl_frame_time_in_seconds_;
   }
 
   scoped_ptr<base::Value> AsValue() const;
   size_t GPUMemoryUsageInBytes() const;
 
   struct RectExpansionCache {
@@ skipping 22 matching lines @@
   friend class TilingEvictionTileIterator;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile> > TileMap;
 
   PictureLayerTiling(float contents_scale,
                      const gfx::Size& layer_bounds,
                      PictureLayerTilingClient* client);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   Tile* CreateTile(int i, int j, const PictureLayerTiling* twin_tiling);
+  void UpdateTileOcclusion(Tile* tile);
+  bool IsTileRequiredForActivation(Tile* tile) const;
 
   // Computes a skewport. The calculation extrapolates the last visible
   // rect and the current visible rect to expand the skewport to where it
   // would be in |skewport_target_time| seconds. Note that the skewport
   // is guaranteed to contain the current visible rect.
   gfx::Rect ComputeSkewport(double current_frame_time_in_seconds,
                             const gfx::Rect& visible_rect_in_content_space)
       const;
 
   void UpdateEvictionCacheIfNeeded(TreePriority tree_priority);
   void DoInvalidate(const Region& layer_region, bool recreate_tiles);
 
+  void SetTilePriority(Tile* tile, bool include_twin) const;
+
   // Given properties.
   float contents_scale_;
   gfx::Size layer_bounds_;
   TileResolution resolution_;
   PictureLayerTilingClient* client_;
 
   // Internal data.
   TilingData tiling_data_;
   TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
   gfx::Rect live_tiles_rect_;
 
+  base::hash_set<std::pair<int, int> > occlusion_set_;

[vmpstr, 2014/07/02 23:51:29]

The idea here is to just store indecies of occluded tiles in update tile
priorities, which remains valid until the next update tile priorities. Then,
tiles are marked as occluded as they are created. I think we can also get away
with just not creating tiles if they are occluded, but for some reason I decided
not to do that (I can't recall what the reason was)... :\

+
   // State saved for computing velocities based upon finite differences.
   double last_impl_frame_time_in_seconds_;
   gfx::Rect last_visible_rect_in_content_space_;
+  float content_to_screen_scale_;
 
   gfx::Rect current_visible_rect_in_content_space_;
   gfx::Rect current_skewport_;
   gfx::Rect current_eventually_rect_;
   gfx::Rect current_soon_border_rect_;
 
   std::vector<Tile*> eviction_tiles_cache_;
-  bool eviction_tiles_cache_valid_;
-  TreePriority eviction_cache_tree_priority_;
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_