cc: Move raster_source from Tile to PrioritizedTile

This moves more of the transitive state of the tile to PrioritizedTile
which has a shorter lifetime, avoiding us to update properties on the
tile.

BUG=

Review URL: https://codereview.chromium.org/1132443003

Cr-Commit-Position: refs/heads/master@{#329556}

18 files changed, 106 insertions, 112 deletions

diff --git a/cc/debug/rasterize_and_record_benchmark_impl.cc b/cc/debug/rasterize_and_record_benchmark_impl.cc
index c5c748b..8edcf1f 100644
--- a/cc/debug/rasterize_and_record_benchmark_impl.cc
+++ b/cc/debug/rasterize_and_record_benchmark_impl.cc
@@ -177,13 +177,13 @@ void RasterizeAndRecordBenchmarkImpl::RunOnLayer(PictureLayerImpl* layer) {
   PictureLayerTiling* tiling = tiling_set->AddTiling(layer->contents_scale_x(),
                                                      layer->GetRasterSource());
   tiling->CreateAllTilesForTesting();
+  RasterSource* raster_source = tiling->raster_source();
   for (PictureLayerTiling::CoverageIterator it(
            tiling, layer->contents_scale_x(), layer->visible_content_rect());
        it;
        ++it) {
     DCHECK(*it);
 
-    RasterSource* raster_source = (*it)->raster_source();
     gfx::Rect content_rect = (*it)->content_rect();
     float contents_scale = (*it)->contents_scale();
 
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 0f922668..c4e59d8 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -1462,8 +1462,8 @@ void LayerImpl::RemoveDependentNeedsPushProperties() {
       parent_->RemoveDependentNeedsPushProperties();
 }
 
-void LayerImpl::GetAllTilesAndPrioritiesForTracing(
-    std::map<const Tile*, TilePriority>* tile_map) const {
+void LayerImpl::GetAllPrioritizedTilesForTracing(
+    std::vector<PrioritizedTile>* prioritized_tiles) const {
 }
 
 void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 6fc5cb2..87ab60b 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -60,6 +60,7 @@ class Occlusion;
 template <typename LayerType>
 class OcclusionTracker;
 class OpacityTree;
+class PrioritizedTile;
 class RenderPass;
 class RenderPassId;
 class Renderer;
@@ -604,8 +605,8 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
   virtual void PushPropertiesTo(LayerImpl* layer);
 
-  virtual void GetAllTilesAndPrioritiesForTracing(
-      std::map<const Tile*, TilePriority>* tile_map) const;
+  virtual void GetAllPrioritizedTilesForTracing(
+      std::vector<PrioritizedTile>* prioritized_tiles) const;
   virtual void AsValueInto(base::trace_event::TracedValue* dict) const;
 
   virtual size_t GPUMemoryUsageInBytes() const;
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f11ad276..0248cf9 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -1183,11 +1183,11 @@ void PictureLayerImpl::GetDebugBorderProperties(
   *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
 
-void PictureLayerImpl::GetAllTilesAndPrioritiesForTracing(
-    std::map<const Tile*, TilePriority>* tile_map) const {
+void PictureLayerImpl::GetAllPrioritizedTilesForTracing(
+    std::vector<PrioritizedTile>* prioritized_tiles) const {
   if (!tilings_)
     return;
-  tilings_->GetAllTilesAndPrioritiesForTracing(tile_map);
+  tilings_->GetAllPrioritizedTilesForTracing(prioritized_tiles);
 }
 
 void PictureLayerImpl::AsValueInto(
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index f8ffc67..f186f82 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -124,8 +124,8 @@ class CC_EXPORT PictureLayerImpl
   bool ShouldAdjustRasterScaleDuringScaleAnimations() const;
 
   void GetDebugBorderProperties(SkColor* color, float* width) const override;
-  void GetAllTilesAndPrioritiesForTracing(
-      std::map<const Tile*, TilePriority>* tile_map) const override;
+  void GetAllPrioritizedTilesForTracing(
+      std::vector<PrioritizedTile>* prioritized_tiles) const override;
   void AsValueInto(base::trace_event::TracedValue* dict) const override;
 
   virtual void UpdateIdealScales();
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index e2df5ef..d27d04b 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -257,9 +257,11 @@ class PictureLayerImplTest : public testing::Test {
     bool resourceless_software_draw = false;
     layer->UpdateTiles(resourceless_software_draw);
   }
-  static void VerifyAllTilesExistAndHavePile(
+  static void VerifyAllPrioritizedTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
@@ -267,7 +269,7 @@ class PictureLayerImplTest : public testing::Test {
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, iter->raster_source());
+      EXPECT_EQ(pile, prioritized_tiles[*iter].raster_source());
     }
   }
 
@@ -696,6 +698,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
@@ -706,7 +710,7 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
       // invalidated and it has the latest raster source.
       if (*iter) {
         EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
+        EXPECT_EQ(pending_pile.get(), prioritized_tiles[*iter].raster_source());
         EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));
       } else {
         // We don't create tiles in non-invalidated regions.
@@ -721,6 +725,8 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation =
         gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
+    auto prioritized_tiles =
+        tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
@@ -730,7 +736,7 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       // Pile will be updated upon activation.
-      EXPECT_EQ(active_pile.get(), iter->raster_source());
+      EXPECT_EQ(active_pile.get(), prioritized_tiles[*iter].raster_source());
     }
   }
 }
@@ -753,7 +759,8 @@ TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
-    VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
+    VerifyAllPrioritizedTilesExistAndHavePile(tilings->tiling_at(i),
+                                              pending_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, UpdateTilesCreatesTilings) {
@@ -4991,8 +4998,12 @@ TEST_F(PictureLayerImplTest, UpdateLCDInvalidatesPendingTree) {
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
   std::vector<Tile*> tiles =
       pending_layer_->HighResTiling()->AllTilesForTesting();
+  auto prioritized_tiles = pending_layer_->HighResTiling()
+                               ->UpdateAndGetAllPrioritizedTilesForTesting();
+
   for (Tile* tile : tiles)
-    EXPECT_EQ(pending_layer_->raster_source(), tile->raster_source());
+    EXPECT_EQ(pending_layer_->raster_source(),
+              prioritized_tiles[tile].raster_source());
 
   pending_layer_->draw_properties().can_use_lcd_text = false;
   pending_layer_->UpdateCanUseLCDTextAfterCommit();
@@ -5001,8 +5012,11 @@ TEST_F(PictureLayerImplTest, UpdateLCDInvalidatesPendingTree) {
   EXPECT_NE(pending_pile.get(), pending_layer_->raster_source());
   EXPECT_TRUE(pending_layer_->HighResTiling()->has_tiles());
   tiles = pending_layer_->HighResTiling()->AllTilesForTesting();
+  prioritized_tiles = pending_layer_->HighResTiling()
+                          ->UpdateAndGetAllPrioritizedTilesForTesting();
   for (Tile* tile : tiles)
-    EXPECT_EQ(pending_layer_->raster_source(), tile->raster_source());
+    EXPECT_EQ(pending_layer_->raster_source(),
+              prioritized_tiles[tile].raster_source());
 }
 
 class TileSizeSettings : public GpuRasterizationEnabledSettings {
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index de2cb4a..e21a3aa 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -138,9 +138,6 @@ void PictureLayerTiling::TakeTilesAndPropertiesFrom(
 
   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()) {
@@ -156,7 +153,6 @@ void PictureLayerTiling::TakeTilesAndPropertiesFrom(
     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());
@@ -297,14 +293,6 @@ void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
     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
@@ -819,12 +807,18 @@ void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const {
 
 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);
@@ -835,13 +829,6 @@ PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() {
   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.
@@ -877,13 +864,10 @@ TilePriority PictureLayerTiling::ComputePriorityForTile(
                       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));
   }
 }
 
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 76723a3..bf04a4c 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -75,7 +75,6 @@ class CC_EXPORT PictureLayerTiling {
 
   void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
-  void SetRasterSourceOnTiles();
   void CreateMissingTilesInLiveTilesRect();
   void TakeTilesAndPropertiesFrom(PictureLayerTiling* pending_twin,
                                   const Region& layer_invalidation);
@@ -120,7 +119,7 @@ class CC_EXPORT PictureLayerTiling {
       UpdateRequiredStatesOnTile(key_tile_pair.second);
   }
   std::map<const Tile*, PrioritizedTile>
-  UpdateAndGetAllPrioritizedTilesForTesting();
+  UpdateAndGetAllPrioritizedTilesForTesting() const;
 
   void SetAllTilesOccludedForTesting() {
     gfx::Rect viewport_in_layer_space =
@@ -134,8 +133,6 @@ class CC_EXPORT PictureLayerTiling {
     return current_visible_rect_;
   }
 
-  void VerifyAllTilesHaveCurrentRasterSource() const;
-
   // 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
@@ -187,8 +184,8 @@ class CC_EXPORT PictureLayerTiling {
                                 double current_frame_time_in_seconds,
                                 const Occlusion& occlusion_in_layer_space);
 
-  void GetAllTilesAndPrioritiesForTracing(
-      std::map<const Tile*, TilePriority>* tile_map) const;
+  void GetAllPrioritizedTilesForTracing(
+      std::vector<PrioritizedTile>* prioritized_tiles) const;
   void AsValueInto(base::trace_event::TracedValue* array) const;
   size_t GPUMemoryUsageInBytes() const;
 
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index 6f540bf..440c9f1 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -112,7 +112,6 @@ void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForActivation(
 
     tiling->SetRasterSourceAndResize(raster_source);
     tiling->Invalidate(layer_invalidation);
-    tiling->SetRasterSourceOnTiles();
     // This is needed for cases where the live tiles rect didn't change but
     // recordings exist in the raster source that did not exist on the last
     // raster source.
@@ -138,7 +137,6 @@ void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForCommit(
   for (PictureLayerTiling* tiling : tilings_) {
     tiling->SetRasterSourceAndResize(raster_source);
     tiling->Invalidate(layer_invalidation);
-    tiling->SetRasterSourceOnTiles();
     // This is needed for cases where the live tiles rect didn't change but
     // recordings exist in the raster source that did not exist on the last
     // raster source.
@@ -156,7 +154,6 @@ void PictureLayerTilingSet::UpdateRasterSourceDueToLCDChange(
     // Since the invalidation changed, we need to create any missing tiles in
     // the live tiles rect again.
     tiling->CreateMissingTilesInLiveTilesRect();
-    tiling->VerifyAllTilesHaveCurrentRasterSource();
   }
 }
 
@@ -373,10 +370,10 @@ bool PictureLayerTilingSet::UpdateTilePriorities(
   return updated;
 }
 
-void PictureLayerTilingSet::GetAllTilesAndPrioritiesForTracing(
-    std::map<const Tile*, TilePriority>* tile_map) const {
+void PictureLayerTilingSet::GetAllPrioritizedTilesForTracing(
+    std::vector<PrioritizedTile>* prioritized_tiles) const {
   for (auto* tiling : tilings_)
-    tiling->GetAllTilesAndPrioritiesForTracing(tile_map);
+    tiling->GetAllPrioritizedTilesForTracing(prioritized_tiles);
 }
 
 PictureLayerTilingSet::CoverageIterator::CoverageIterator(
diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h
index e51d7ec..883c8d0 100644
--- a/cc/resources/picture_layer_tiling_set.h
+++ b/cc/resources/picture_layer_tiling_set.h
@@ -121,8 +121,8 @@ class CC_EXPORT PictureLayerTilingSet {
                             const Occlusion& occlusion_in_layer_space,
                             bool can_require_tiles_for_activation);
 
-  void GetAllTilesAndPrioritiesForTracing(
-      std::map<const Tile*, TilePriority>* tile_map) const;
+  void GetAllPrioritizedTilesForTracing(
+      std::vector<PrioritizedTile>* prioritized_tiles) const;
 
   // For a given rect, iterates through tiles that can fill it.  If no
   // set of tiles with resources can fill the rect, then it will iterate
diff --git a/cc/resources/prioritized_tile.cc b/cc/resources/prioritized_tile.cc
index 3a9f815..7052507 100644
--- a/cc/resources/prioritized_tile.cc
+++ b/cc/resources/prioritized_tile.cc
@@ -8,16 +8,33 @@
 
 namespace cc {
 
-PrioritizedTile::PrioritizedTile() : tile_(nullptr), is_occluded_(false) {
+PrioritizedTile::PrioritizedTile()
+    : tile_(nullptr), raster_source_(nullptr), is_occluded_(false) {
 }
 
 PrioritizedTile::PrioritizedTile(Tile* tile,
+                                 RasterSource* raster_source,
                                  const TilePriority priority,
                                  bool is_occluded)
-    : tile_(tile), priority_(priority), is_occluded_(is_occluded) {
+    : tile_(tile),
+      raster_source_(raster_source),
+      priority_(priority),
+      is_occluded_(is_occluded) {
 }
 
 PrioritizedTile::~PrioritizedTile() {
 }
 
+void PrioritizedTile::AsValueInto(base::trace_event::TracedValue* value) const {
+  tile_->AsValueInto(value);
+
+  TracedValue::SetIDRef(raster_source(), value, "picture_pile");
+
+  value->BeginDictionary("combined_priority");
+  priority().AsValueInto(value);
+  value->EndDictionary();
+
+  value->SetString("resolution", TileResolutionToString(priority().resolution));
+}
+
 }  // namespace cc
diff --git a/cc/resources/prioritized_tile.h b/cc/resources/prioritized_tile.h
index b26476a..3ac09fc 100644
--- a/cc/resources/prioritized_tile.h
+++ b/cc/resources/prioritized_tile.h
@@ -11,6 +11,7 @@
 
 namespace cc {
 class PictureLayerTiling;
+class RasterSource;
 
 class CC_EXPORT PrioritizedTile {
  public:
@@ -20,15 +21,22 @@ class CC_EXPORT PrioritizedTile {
   ~PrioritizedTile();
 
   Tile* tile() const { return tile_; }
+  RasterSource* raster_source() const { return raster_source_; }
   const TilePriority& priority() const { return priority_; }
   bool is_occluded() const { return is_occluded_; }
 
+  void AsValueInto(base::trace_event::TracedValue* value) const;
+
  private:
   friend class PictureLayerTiling;
 
-  PrioritizedTile(Tile* tile, const TilePriority priority, bool is_occluded);
+  PrioritizedTile(Tile* tile,
+                  RasterSource* raster_source,
+                  const TilePriority priority,
+                  bool is_occluded);
 
   Tile* tile_;
+  RasterSource* raster_source_;
   TilePriority priority_;
   bool is_occluded_;
 };
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 2faa6e4..58a92c7 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -36,7 +36,6 @@ Tile::Tile(TileManager* tile_manager,
       required_for_draw_(false),
       id_(s_next_id_++),
       scheduled_priority_(0) {
-  set_raster_source(raster_source);
 }
 
 Tile::~Tile() {
@@ -45,34 +44,27 @@ Tile::~Tile() {
       "cc::Tile", this);
 }
 
-void Tile::AsValueWithPriorityInto(const TilePriority& priority,
-                                   base::trace_event::TracedValue* res) const {
+void Tile::AsValueInto(base::trace_event::TracedValue* value) const {
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug"), res, "cc::Tile", this);
-  TracedValue::SetIDRef(raster_source_.get(), res, "picture_pile");
-  res->SetDouble("contents_scale", contents_scale_);
+      TRACE_DISABLED_BY_DEFAULT("cc.debug"), value, "cc::Tile", this);
+  value->SetDouble("contents_scale", contents_scale_);
 
-  MathUtil::AddToTracedValue("content_rect", content_rect_, res);
+  MathUtil::AddToTracedValue("content_rect", content_rect_, value);
 
-  res->SetInteger("layer_id", layer_id_);
+  value->SetInteger("layer_id", layer_id_);
 
-  res->BeginDictionary("combined_priority");
-  priority.AsValueInto(res);
-  res->EndDictionary();
+  value->BeginDictionary("draw_info");
+  draw_info_.AsValueInto(value);
+  value->EndDictionary();
 
-  res->BeginDictionary("draw_info");
-  draw_info_.AsValueInto(res);
-  res->EndDictionary();
+  value->SetBoolean("has_resource", HasResource());
+  value->SetBoolean("is_using_gpu_memory", HasResource() || HasRasterTask());
 
-  res->SetBoolean("has_resource", HasResource());
-  res->SetBoolean("is_using_gpu_memory", HasResource() || HasRasterTask());
-  res->SetString("resolution", TileResolutionToString(priority.resolution));
+  value->SetInteger("scheduled_priority", scheduled_priority_);
 
-  res->SetInteger("scheduled_priority", scheduled_priority_);
+  value->SetBoolean("use_picture_analysis", use_picture_analysis());
 
-  res->SetBoolean("use_picture_analysis", use_picture_analysis());
-
-  res->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
+  value->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 }
 
 size_t Tile::GPUMemoryUsageInBytes() const {
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 4d41ebf..25e9265 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -13,6 +13,7 @@
 
 namespace cc {
 
+class PrioritizedTile;
 class TileManager;
 struct TilePriority;
 
@@ -31,10 +32,6 @@ class CC_EXPORT Tile {
     return id_;
   }
 
-  RasterSource* raster_source() { return raster_source_.get(); }
-
-  const RasterSource* raster_source() const { return raster_source_.get(); }
-
   // TODO(vmpstr): Move this to the iterators.
   bool required_for_activation() const { return required_for_activation_; }
   void set_required_for_activation(bool is_required) {
@@ -55,8 +52,7 @@ class CC_EXPORT Tile {
            !draw_info_.IsReadyToDraw();
   }
 
-  void AsValueWithPriorityInto(const TilePriority& priority,
-                               base::trace_event::TracedValue* dict) const;
+  void AsValueInto(base::trace_event::TracedValue* value) const;
 
   inline bool IsReadyToDraw() const { return draw_info_.IsReadyToDraw(); }
 
@@ -71,14 +67,6 @@ class CC_EXPORT Tile {
 
   int source_frame_number() const { return source_frame_number_; }
 
-  void set_raster_source(RasterSource* raster_source) {
-    DCHECK(raster_source->CoversRect(content_rect_, contents_scale_))
-        << "Recording rect: "
-        << gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_)
-               .ToString();
-    raster_source_ = raster_source;
-  }
-
   size_t GPUMemoryUsageInBytes() const;
 
   gfx::Size desired_texture_size() const { return desired_texture_size_; }
@@ -109,7 +97,6 @@ class CC_EXPORT Tile {
   bool HasRasterTask() const { return !!raster_task_.get(); }
 
   TileManager* tile_manager_;
-  scoped_refptr<RasterSource> raster_source_;
   gfx::Size desired_texture_size_;
   gfx::Rect content_rect_;
   float contents_scale_;
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index b752303a..442d7ad 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -660,7 +660,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   std::vector<SkPixelRef*> pixel_refs;
-  tile->raster_source()->GatherPixelRefs(
+  prioritized_tile.raster_source()->GatherPixelRefs(
       tile->content_rect(), tile->contents_scale(), &pixel_refs);
   for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
@@ -680,7 +680,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
   }
 
   return make_scoped_refptr(new RasterTaskImpl(
-      const_resource, tile->raster_source(), tile->content_rect(),
+      const_resource, prioritized_tile.raster_source(), tile->content_rect(),
       tile->contents_scale(), prioritized_tile.priority().resolution,
       tile->layer_id(), static_cast<const void*>(tile),
       tile->source_frame_number(), tile->use_picture_analysis(),
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 0bf4059..126fd09 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -3177,18 +3177,15 @@ void LayerTreeHostImpl::AsValueWithFrameInto(
   MathUtil::AddToTracedValue("device_viewport_size", device_viewport_size_,
                              state);
 
-  std::map<const Tile*, TilePriority> tile_map;
-  active_tree_->GetAllTilesAndPrioritiesForTracing(&tile_map);
+  std::vector<PrioritizedTile> prioritized_tiles;
+  active_tree_->GetAllPrioritizedTilesForTracing(&prioritized_tiles);
   if (pending_tree_)
-    pending_tree_->GetAllTilesAndPrioritiesForTracing(&tile_map);
+    pending_tree_->GetAllPrioritizedTilesForTracing(&prioritized_tiles);
 
   state->BeginArray("active_tiles");
-  for (const auto& pair : tile_map) {
-    const Tile* tile = pair.first;
-    const TilePriority& priority = pair.second;
-
+  for (const auto& prioritized_tile : prioritized_tiles) {
     state->BeginDictionary();
-    tile->AsValueWithPriorityInto(priority, state);
+    prioritized_tile.AsValueInto(state);
     state->EndDictionary();
   }
   state->EndArray();
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 25f48d6..2768859 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -955,8 +955,8 @@ AnimationRegistrar* LayerTreeImpl::GetAnimationRegistrar() const {
   return layer_tree_host_impl_->animation_registrar();
 }
 
-void LayerTreeImpl::GetAllTilesAndPrioritiesForTracing(
-    std::map<const Tile*, TilePriority>* tile_map) const {
+void LayerTreeImpl::GetAllPrioritizedTilesForTracing(
+    std::vector<PrioritizedTile>* prioritized_tiles) const {
   typedef LayerIterator<LayerImpl> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
   for (LayerIteratorType it =
@@ -966,7 +966,7 @@ void LayerTreeImpl::GetAllTilesAndPrioritiesForTracing(
     if (!it.represents_itself())
       continue;
     LayerImpl* layer_impl = *it;
-    layer_impl->GetAllTilesAndPrioritiesForTracing(tile_map);
+    layer_impl->GetAllPrioritizedTilesForTracing(prioritized_tiles);
   }
 }
 
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 76911e1..9c1b5b9 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -119,8 +119,8 @@ class CC_EXPORT LayerTreeImpl {
 
   // Tracing methods.
   // ---------------------------------------------------------------------------
-  void GetAllTilesAndPrioritiesForTracing(
-      std::map<const Tile*, TilePriority>* tile_map) const;
+  void GetAllPrioritizedTilesForTracing(
+      std::vector<PrioritizedTile>* prioritized_tiles) const;
   void AsValueInto(base::trace_event::TracedValue* dict) const;
 
   // Other public methods