cc: Move raster_source from Tile to PrioritizedTile

cc/resources/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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 120 matching lines @@
 }
 
 void PictureLayerTiling::TakeTilesAndPropertiesFrom(
     PictureLayerTiling* pending_twin,
     const Region& layer_invalidation) {
   TRACE_EVENT0("cc", "TakeTilesAndPropertiesFrom");
   SetRasterSourceAndResize(pending_twin->raster_source_);
 
   RemoveTilesInRegion(layer_invalidation, false /* recreate tiles */);
 
-  for (TileMap::value_type& tile_pair : tiles_)
-    tile_pair.second->set_raster_source(raster_source_.get());
-
   resolution_ = pending_twin->resolution_;
   bool create_missing_tiles = false;
   if (live_tiles_rect_.IsEmpty()) {
     live_tiles_rect_ = pending_twin->live_tiles_rect();
     create_missing_tiles = true;
   } else {
     SetLiveTilesRect(pending_twin->live_tiles_rect());
   }
 
   if (tiles_.empty()) {
     tiles_.swap(pending_twin->tiles_);
   } else {
     while (!pending_twin->tiles_.empty()) {
       TileMapKey key = pending_twin->tiles_.begin()->first;
       tiles_.set(key, pending_twin->tiles_.take_and_erase(key));
-      DCHECK(tiles_.get(key)->raster_source() == raster_source_.get());
     }
   }
   DCHECK(pending_twin->tiles_.empty());
 
   if (create_missing_tiles)
     CreateMissingTilesInLiveTilesRect();
 
   VerifyLiveTilesRect(false);
 
   SetTilePriorityRects(pending_twin->current_content_to_screen_scale_,
@@ skipping 120 matching lines @@
         if (recreate_tiles)
           new_tile_keys.push_back(iter.index());
       }
     }
   }
 
   for (const auto& key : new_tile_keys)
     CreateTile(key.first, key.second);
 }
 
-void PictureLayerTiling::SetRasterSourceOnTiles() {
-  if (tree_ == PENDING_TREE)
-    return;
-
-  for (TileMap::value_type& tile_pair : tiles_)
-    tile_pair.second->set_raster_source(raster_source_.get());
-}
-
 bool PictureLayerTiling::ShouldCreateTileAt(int i, int j) const {
   // Active tree should always create a tile. The reason for this is that active
   // tree represents content that we draw on screen, which means that whenever
   // we check whether a tile should exist somewhere, the answer is yes. This
   // doesn't mean it will actually be created (if raster source doesn't cover
   // the tile for instance). Pending tree, on the other hand, should only be
   // creating tiles that are different from the current active tree, which is
   // represented by the logic in the rest of the function.
   if (tree_ == ACTIVE_TREE)
     return true;
@@ skipping 494 matching lines @@
 }
 
 void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const {
   DCHECK(tile);
   tile->set_required_for_activation(IsTileRequiredForActivation(tile));
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
 }
 
 PrioritizedTile PictureLayerTiling::MakePrioritizedTile(Tile* tile) const {
   DCHECK(tile);
-  return PrioritizedTile(tile, ComputePriorityForTile(tile),
+  DCHECK(
+      raster_source()->CoversRect(tile->content_rect(), tile->contents_scale()))
+      << "Recording rect: "
+      << gfx::ScaleToEnclosingRect(tile->content_rect(),
+                                   1.f / tile->contents_scale()).ToString();
+
+  return PrioritizedTile(tile, raster_source(), ComputePriorityForTile(tile),
                          IsTileOccluded(tile));
 }
 
 std::map<const Tile*, PrioritizedTile>
-PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() {
+PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
     UpdateRequiredStatesOnTile(key_tile_pair.second);
     PrioritizedTile prioritized_tile =
         MakePrioritizedTile(key_tile_pair.second);
     result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
   }
   return result;
 }
 
-void PictureLayerTiling::VerifyAllTilesHaveCurrentRasterSource() const {
-#if DCHECK_IS_ON()
-  for (const auto& tile_pair : tiles_)
-    DCHECK_EQ(raster_source_.get(), tile_pair.second->raster_source());
-#endif
-}
-
 TilePriority PictureLayerTiling::ComputePriorityForTile(
     const Tile* tile) const {
   // TODO(vmpstr): See if this can be moved to iterators.
   TilePriority::PriorityBin max_tile_priority_bin =
       client_->GetMaxTilePriorityBin();
 
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
   gfx::Rect tile_bounds =
       tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
@@ skipping 15 matching lines @@
   if (max_tile_priority_bin <= TilePriority::SOON &&
       (current_soon_border_rect_.Intersects(tile_bounds) ||
        current_skewport_rect_.Intersects(tile_bounds))) {
     return TilePriority(resolution_, TilePriority::SOON, distance_to_visible);
   }
 
   return TilePriority(resolution_, TilePriority::EVENTUALLY,
                       distance_to_visible);
 }
 
-void PictureLayerTiling::GetAllTilesAndPrioritiesForTracing(
-    std::map<const Tile*, TilePriority>* tile_map) const {
+void PictureLayerTiling::GetAllPrioritizedTilesForTracing(
+    std::vector<PrioritizedTile>* prioritized_tiles) const {
   for (const auto& tile_pair : tiles_) {
-    const Tile* tile = tile_pair.second;
-    const TilePriority& priority = ComputePriorityForTile(tile);
-    // Store combined priority.
-    (*tile_map)[tile] = priority;
+    prioritized_tiles->push_back(MakePrioritizedTile(tile_pair.second));
   }
 }
 
 void PictureLayerTiling::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   MathUtil::AddToTracedValue("visible_rect", current_visible_rect_, state);
   MathUtil::AddToTracedValue("skewport_rect", current_skewport_rect_, state);
   MathUtil::AddToTracedValue("soon_rect", current_soon_border_rect_, state);
@@ skipping 156 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc