cc: Remove GetRasterSource from PictureLayerTilingClient.

cc/resources/picture_layer_tiling_set.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_set.h"
 
 #include <limits>
 
 namespace cc {
 
 namespace {
 
 class LargestToSmallestScaleFunctor {
  public:
   bool operator() (PictureLayerTiling* left, PictureLayerTiling* right) {
     return left->contents_scale() > right->contents_scale();
   }
 };
 
 }  // namespace
 
-PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client)
-    : client_(client) {
+// static
+scoped_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
+    PictureLayerTilingClient* client,
+    RasterSource* raster_source) {
+  return make_scoped_ptr(new PictureLayerTilingSet(client, raster_source));
+}
+
+PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client,
+                                             RasterSource* raster_source)
+    : client_(client), raster_source_(raster_source) {
 }
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
 void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->SetClient(client_);
 }
 
+void PictureLayerTilingSet::SetRasterSource(RasterSource* raster_source) {
+  raster_source_ = raster_source;
+}
+
 void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->RemoveTilesInRegion(region);
 }
 
 bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,

[danakj, 2014/11/14 21:39:51]

how about passing it in here instead of adding a member variable to PLTS?

[vmpstr, 2014/11/14 23:49:02]

I kind of like it as a PLTS member... My reason is that PLTS itself is a thing
that should know about the current raster source, since if we move towards it
being more opaque to the layer, it makes sense that a cache for rasterized
content is aware of the source of said rasterization (... if that makes any
sense ...)

I do see the flip side that it's more difficult to maintain if we have to set it
independently. However, I think it's worth the effort. I think the fact that we
UpdateTilesToCurrentRasterSource is called in SyncTilings is pretty arbitrary.
That is, I can picture a system where SyncTilings grabs tilings and invalidates
stuff, and SetRasterSource is the thing that UpdatesToCurrentRasterSource.

Maybe? I think this is more of a design choice than anything here, so if you
feel strongly about it, I can change it. Wdyt?

                                         const gfx::Size& new_layer_bounds,
                                         const Region& layer_invalidation,
                                         float minimum_contents_scale) {
   if (new_layer_bounds.IsEmpty()) {
     RemoveAllTilings();
     return false;
   }
 
   tilings_.reserve(other.tilings_.size());
 
   // Remove any tilings that aren't in |other| or don't meet the minimum.
   for (size_t i = 0; i < tilings_.size(); ++i) {
     float scale = tilings_[i]->contents_scale();
     if (scale >= minimum_contents_scale && !!other.TilingAtScale(scale))
       continue;
     // Swap with the last element and remove it.
     tilings_.swap(tilings_.begin() + i, tilings_.end() - 1);
     tilings_.pop_back();
     --i;
   }
 
+  DCHECK(raster_source_);
   bool have_high_res_tiling = false;
 
   // Add any missing tilings from |other| that meet the minimum.
   for (size_t i = 0; i < other.tilings_.size(); ++i) {
     float contents_scale = other.tilings_[i]->contents_scale();
     if (contents_scale < minimum_contents_scale)
       continue;
     if (PictureLayerTiling* this_tiling = TilingAtScale(contents_scale)) {
       this_tiling->set_resolution(other.tilings_[i]->resolution());
 
-      this_tiling->UpdateTilesToCurrentRasterSource(layer_invalidation,
-                                                    new_layer_bounds);
+      this_tiling->UpdateTilesToCurrentRasterSource(
+          raster_source_, layer_invalidation, new_layer_bounds);
       this_tiling->CreateMissingTilesInLiveTilesRect();
       if (this_tiling->resolution() == HIGH_RESOLUTION)
         have_high_res_tiling = true;
 
       DCHECK(this_tiling->tile_size() ==
              client_->CalculateTileSize(this_tiling->tiling_size()))
           << "tile_size: " << this_tiling->tile_size().ToString()
           << " tiling_size: " << this_tiling->tiling_size().ToString()
           << " CalculateTileSize: "
           << client_->CalculateTileSize(this_tiling->tiling_size()).ToString();
@@ skipping 281 matching lines @@
     case LOWER_THAN_LOW_RES:
       range = TilingRange(low_res_range.end, tilings_.size());
       break;
   }
 
   DCHECK_LE(range.start, range.end);
   return range;
 }
 
 }  // namespace cc