Chromium -> Mojo roll.

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 <map>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/tiling_data.h"
 #include "cc/resources/tile.h"
@@ skipping 114 matching lines @@
 
   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 UpdateTileAndTwinPriority(Tile* tile) const;
+  TilePriority ComputePriorityForTile(const Tile* tile) const;
+  void UpdateRequiredStateForTile(Tile* tile, WhichTree tree) 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_;
   }
@@ skipping 51 matching lines @@
     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 GetAllTilesForTracing(std::set<const Tile*>* tiles) const;
+  void GetAllTilesAndPrioritiesForTracing(
+      std::map<const Tile*, TilePriority>* tile_map) const;
   void AsValueInto(base::trace_event::TracedValue* array) const;
   size_t GPUMemoryUsageInBytes() const;
 
   struct RectExpansionCache {
     RectExpansionCache();
 
     gfx::Rect previous_start;
     gfx::Rect previous_bounds;
     gfx::Rect previous_result;
     int64 previous_target;
   };
 
   static
   gfx::Rect ExpandRectEquallyToAreaBoundedBy(
       const gfx::Rect& starting_rect,
       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;
+    return visible_rect_history_[0].frame_time_in_seconds != 0.0;
   }
 
  protected:
   friend class CoverageIterator;
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 
+  struct FrameVisibleRect {
+    gfx::Rect visible_rect_in_content_space;
+    double frame_time_in_seconds = 0.0;
+  };
+
   PictureLayerTiling(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);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
   Tile* CreateTile(int i,
                    int j,
@@ skipping 15 matching lines @@
                                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 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_ ||
+    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];
+  }
 
   const size_t max_tiles_for_interest_area_;
   const float skewport_target_time_in_seconds_;
   const int skewport_extrapolation_limit_in_content_pixels_;
 
   // Given properties.
   const float contents_scale_;
   PictureLayerTilingClient* const client_;
   scoped_refptr<RasterSource> raster_source_;
   TileResolution resolution_;
 
   // 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.
-  double last_impl_frame_time_in_seconds_;
-  gfx::Rect last_viewport_in_layer_space_;
-  gfx::Rect last_visible_rect_in_content_space_;
+  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_;
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_