cc: Move prepaint region calculations to the tiling set.

cc/tiles/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_TILES_PICTURE_LAYER_TILING_H_
 #define CC_TILES_PICTURE_LAYER_TILING_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 62 matching lines @@
     uint16_t value2 = static_cast<uint16_t>(key.index_y);
     uint32_t value1_32 = value1;
     return (value1_32 << 16) | value2;
   }
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
-  PictureLayerTilingClient* client() const { return client_; }
+  PictureLayerTiling(WhichTree tree,
+                     float contents_scale,
+                     scoped_refptr<RasterSource> raster_source,
+                     PictureLayerTilingClient* client);
   ~PictureLayerTiling();
 
-  static float CalculateSoonBorderDistance(
-      const gfx::Rect& visible_rect_in_content_space,
-      float content_to_screen_scale);
-
-  // Create a tiling with no tiles. CreateTile() must be called to add some.
-  static std::unique_ptr<PictureLayerTiling> Create(
-      WhichTree tree,
-      float contents_scale,
-      scoped_refptr<RasterSource> raster_source,
-      PictureLayerTilingClient* client,
-      size_t tiling_interest_area_padding,
-      float skewport_target_time_in_seconds,
-      int skewport_extrapolation_limit_in_content_pixels);
+  PictureLayerTilingClient* client() const { return client_; }
 
   void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
   void CreateMissingTilesInLiveTilesRect();
   void TakeTilesAndPropertiesFrom(PictureLayerTiling* pending_twin,
                                   const Region& layer_invalidation);
 
   bool IsTileRequiredForActivation(const Tile* tile) const;
   bool IsTileRequiredForDraw(const Tile* tile) const;
 
@@ skipping 120 matching lines @@
     int left_;
     int top_;
     int right_;
     int bottom_;
 
     friend class PictureLayerTiling;
   };
 
   void Reset();
 
-  bool ComputeTilePriorityRects(const gfx::Rect& viewport_in_layer_space,
-                                float ideal_contents_scale,
-                                double current_frame_time_in_seconds,
-                                const Occlusion& occlusion_in_layer_space);
+  void ComputeTilePriorityRects(
+      const gfx::Rect& visible_rect_in_layer_space,
+      const gfx::Rect& skewport_in_layer_space,
+      const gfx::Rect& soon_border_rect_in_layer_space,
+      const gfx::Rect& eventually_rect_in_layer_space,
+      float ideal_contents_scale,
+      const Occlusion& occlusion_in_layer_space);
 
   void GetAllPrioritizedTilesForTracing(
       std::vector<PrioritizedTile>* prioritized_tiles) const;
   void AsValueInto(base::trace_event::TracedValue* array) const;
   size_t GPUMemoryUsageInBytes() const;
 
  protected:
   friend class CoverageIterator;
   friend class PrioritizedTile;
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
   // PENDING VISIBLE RECT refers to the visible rect that will become current
   // upon activation (ie, the pending tree's visible rect). Tiles in this
   // region that are not part of the current visible rect are all handled
   // here. Note that when processing a pending tree, this rect is the same as
   // the visible rect so no tiles are processed in this case.
   enum PriorityRectType {
     VISIBLE_RECT,
     PENDING_VISIBLE_RECT,
     SKEWPORT_RECT,
     SOON_BORDER_RECT,
     EVENTUALLY_RECT
   };
 
   using TileMap = std::unordered_map<TileMapKey, ScopedTilePtr, TileMapKeyHash>;
 
-  struct FrameVisibleRect {
-    gfx::Rect visible_rect_in_content_space;
-    double frame_time_in_seconds = 0.0;
-  };
-
-  PictureLayerTiling(WhichTree tree,
-                     float contents_scale,
-                     scoped_refptr<RasterSource> raster_source,
-                     PictureLayerTilingClient* client,
-                     size_t tiling_interest_area_padding,
-                     float skewport_target_time_in_seconds,
-                     int skewport_extrapolation_limit_in_content_pixels);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
   Tile* CreateTile(const Tile::CreateInfo& info);
   ScopedTilePtr TakeTileAt(int i, int j);
   // Returns true if the Tile existed and was removed from the tiling.
   bool RemoveTileAt(int i, int j);
   bool TilingMatchesTileIndices(const PictureLayerTiling* twin) 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;
-
   // Save the required data for computing tile priorities later.
   void SetTilePriorityRects(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);
 
-  bool NeedsUpdateForFrameAtTimeAndViewport(
-      double frame_time_in_seconds,
-      const gfx::Rect& viewport_in_layer_space) {
-    return frame_time_in_seconds !=
-               visible_rect_history_[0].frame_time_in_seconds ||
-           viewport_in_layer_space != last_viewport_in_layer_space_;
-  }
-  void UpdateVisibleRectHistory(
-      double frame_time_in_seconds,
-      const gfx::Rect& visible_rect_in_content_space) {
-    visible_rect_history_[1] = visible_rect_history_[0];
-    visible_rect_history_[0].frame_time_in_seconds = frame_time_in_seconds;
-    visible_rect_history_[0].visible_rect_in_content_space =
-        visible_rect_in_content_space;
-    // If we don't have a second history item, set it to the most recent one.
-    if (visible_rect_history_[1].frame_time_in_seconds == 0.0)
-      visible_rect_history_[1] = visible_rect_history_[0];
-  }
   bool IsTileOccludedOnCurrentTree(const Tile* tile) const;
   Tile::CreateInfo CreateInfoForTile(int i, int j) const;
   bool ShouldCreateTileAt(const Tile::CreateInfo& info) const;
   bool IsTileOccluded(const Tile* tile) const;
   void UpdateRequiredStatesOnTile(Tile* tile) const;
   PrioritizedTile MakePrioritizedTile(
       Tile* tile,
       PriorityRectType priority_rect_type) const;
   TilePriority ComputePriorityForTile(
       const Tile* tile,
@@ skipping 19 matching lines @@
   }
   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_;
   }
-  bool has_ever_been_updated() const {
-    return visible_rect_history_[0].frame_time_in_seconds != 0.0;
-  }
   void RemoveTilesInRegion(const Region& layer_region, bool recreate_tiles);
 
-  const size_t tiling_interest_area_padding_;
-  const float skewport_target_time_in_seconds_;
-  const int skewport_extrapolation_limit_in_content_pixels_;
-
   // Given properties.
   const float contents_scale_;
   PictureLayerTilingClient* const client_;
   const WhichTree tree_;
   scoped_refptr<RasterSource> raster_source_;
   TileResolution resolution_;
   bool may_contain_low_resolution_tiles_;
 
   // 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_;
 
-  gfx::Rect last_viewport_in_layer_space_;
-  // State saved for computing velocities based upon finite differences.
-  FrameVisibleRect visible_rect_history_[2];
-
   bool can_require_tiles_for_activation_;
 
   // Iteration rects in content space.
   gfx::Rect current_visible_rect_;
   gfx::Rect current_skewport_rect_;
   gfx::Rect current_soon_border_rect_;
   gfx::Rect current_eventually_rect_;
   // Other properties used for tile iteration and prioritization.
   float current_content_to_screen_scale_;
   Occlusion current_occlusion_in_layer_space_;
 
   bool has_visible_rect_tiles_;
   bool has_skewport_rect_tiles_;
   bool has_soon_border_rect_tiles_;
   bool has_eventually_rect_tiles_;
   bool all_tiles_done_;
-  bool invalidated_since_last_compute_priority_rects_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTiling);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_PICTURE_LAYER_TILING_H_