cc: Move tiling raster tile iterator to be a tiling set queue class.

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 <set>
 #include <utility>
 #include <vector>
@@ skipping 40 matching lines @@
   virtual bool RequiresHighResToDraw() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
-  class CC_EXPORT TilingRasterTileIterator {
-   public:
-    TilingRasterTileIterator();
-    explicit TilingRasterTileIterator(PictureLayerTiling* tiling);
-    ~TilingRasterTileIterator();
-
-    operator bool() const { return !!current_tile_; }
-    const Tile* operator*() const { return current_tile_; }
-    Tile* operator*() { return current_tile_; }
-    TilePriority::PriorityBin get_type() const {
-      switch (phase_) {
-        case VISIBLE_RECT:
-          return TilePriority::NOW;
-        case SKEWPORT_RECT:
-        case SOON_BORDER_RECT:
-          return TilePriority::SOON;
-        case EVENTUALLY_RECT:
-          return TilePriority::EVENTUALLY;
-      }
-      NOTREACHED();
-      return TilePriority::EVENTUALLY;
-    }
-
-    TilingRasterTileIterator& operator++();
-
-   private:
-    enum Phase {
-      VISIBLE_RECT,
-      SKEWPORT_RECT,
-      SOON_BORDER_RECT,
-      EVENTUALLY_RECT
-    };
-
-    void AdvancePhase();
-    bool TileNeedsRaster(Tile* tile) const {
-      return tile->NeedsRaster() && !tiling_->IsTileOccluded(tile);
-    }
-
-    PictureLayerTiling* tiling_;
-
-    Phase phase_;
-
-    Tile* current_tile_;
-    TilingData::Iterator visible_iterator_;
-    TilingData::SpiralDifferenceIterator spiral_iterator_;
-  };
-
   ~PictureLayerTiling();
 
   // Create a tiling with no tiles. CreateTile() must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       scoped_refptr<RasterSource> raster_source,
       PictureLayerTilingClient* client,
       size_t max_tiles_for_interest_area,
       float skewport_target_time_in_seconds,
       int skewport_extrapolation_limit_in_content_pixels);
@@ skipping 30 matching lines @@
 
   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;
   }
 
   void UpdateAllTilePrioritiesForTesting() {
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-      UpdateTileAndTwinPriority(it->second.get());
+      UpdateTilePriority(it->second.get());
   }
 
   std::vector<scoped_refptr<Tile>> AllRefTilesForTesting() const {
     std::vector<scoped_refptr<Tile>> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       all_tiles.push_back(it->second);
     return all_tiles;
   }
 
   void SetAllTilesOccludedForTesting() {
     gfx::Rect viewport_in_layer_space =
         ScaleToEnclosingRect(current_visible_rect_, 1.0f / contents_scale_);
     current_occlusion_in_layer_space_ =
         Occlusion(gfx::Transform(),
                   SimpleEnclosedRegion(viewport_in_layer_space),
                   SimpleEnclosedRegion(viewport_in_layer_space));
   }
 
   const gfx::Rect& GetCurrentVisibleRectForTesting() const {
     return current_visible_rect_;
   }
 
   bool IsTileOccluded(const Tile* tile) const;
   bool IsTileRequiredForActivationIfVisible(const Tile* tile) const;
   bool IsTileRequiredForDrawIfVisible(const Tile* tile) const;
 
+  void UpdateTilePriority(Tile* tile) const;
+  bool has_visible_rect_tiles() const { return has_visible_rect_tiles_; }
+  bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_; }
+  bool has_soon_border_rect_tiles() const {
+    return has_soon_border_rect_tiles_;
+  }
+  bool has_eventually_rect_tiles() const { return has_eventually_rect_tiles_; }
+
+  const gfx::Rect& current_visible_rect() const {
+    return current_visible_rect_;
+  }
+  const gfx::Rect& current_skewport_rect() const {
+    return current_skewport_rect_;
+  }
+  const gfx::Rect& current_soon_border_rect() const {
+    return current_soon_border_rect_;
+  }
+  const gfx::Rect& current_eventually_rect() const {
+    return current_eventually_rect_;
+  }
+
   // Iterate over all tiles to fill content_rect.  Even if tiles are invalid
   // (i.e. no valid resource) this tiling should still iterate over them.
   // The union of all geometry_rect calls for each element iterated over should
   // exactly equal content_rect and no two geometry_rects should intersect.
   class CC_EXPORT CoverageIterator {
    public:
     CoverageIterator();
     CoverageIterator(const PictureLayerTiling* tiling,
         float dest_scale,
         const gfx::Rect& rect);
@@ skipping 57 matching lines @@
       int64 target_area,
       const gfx::Rect& bounding_rect,
       RectExpansionCache* cache);
 
   bool has_ever_been_updated() const {
     return last_impl_frame_time_in_seconds_ != 0.0;
   }
 
  protected:
   friend class CoverageIterator;
-  friend class TilingRasterTileIterator;
+  friend class TilingSetRasterQueue;
   friend class TilingSetEvictionQueue;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 
   PictureLayerTiling(float contents_scale,
                      scoped_refptr<RasterSource> raster_source,
                      PictureLayerTilingClient* client,
                      size_t max_tiles_for_interest_area,
                      float skewport_target_time_in_seconds,
@@ skipping 16 matching lines @@
       const;
 
   // Save the required data for computing tile priorities later.
   void UpdateTilePriorityRects(float content_to_screen_scale_,
                                const gfx::Rect& visible_rect_in_content_space,
                                const gfx::Rect& skewport,
                                const gfx::Rect& soon_border_rect,
                                const gfx::Rect& eventually_rect,
                                const Occlusion& occlusion_in_layer_space);
 
-  void UpdateTileAndTwinPriority(Tile* tile) const;
-  void UpdateTilePriority(Tile* tile) const;
+  void UpdateTilePriorityForTree(Tile* tile, WhichTree tree) const;
   bool NeedsUpdateForFrameAtTimeAndViewport(
       double frame_time_in_seconds,
       const gfx::Rect& viewport_in_layer_space) {
     return frame_time_in_seconds != last_impl_frame_time_in_seconds_ ||
            viewport_in_layer_space != last_viewport_in_layer_space_;
   }
 
   const size_t max_tiles_for_interest_area_;
   const float skewport_target_time_in_seconds_;
   const int skewport_extrapolation_limit_in_content_pixels_;
@@ skipping 32 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_