Update from https://crrev.com/309415

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 11 matching lines @@
 
 namespace cc {
 namespace {
 
 const float kSoonBorderDistanceInScreenPixels = 312.f;
 
 }  // namespace
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
-    const gfx::Size& layer_bounds,
+    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) {
   return make_scoped_ptr(new PictureLayerTiling(
-      contents_scale, layer_bounds, client, max_tiles_for_interest_area,
+      contents_scale, raster_source, client, max_tiles_for_interest_area,
       skewport_target_time_in_seconds,
       skewport_extrapolation_limit_in_content_pixels));
 }
 
 PictureLayerTiling::PictureLayerTiling(
     float contents_scale,
-    const gfx::Size& layer_bounds,
+    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)
     : max_tiles_for_interest_area_(max_tiles_for_interest_area),
       skewport_target_time_in_seconds_(skewport_target_time_in_seconds),
       skewport_extrapolation_limit_in_content_pixels_(
           skewport_extrapolation_limit_in_content_pixels),
       contents_scale_(contents_scale),
       client_(client),
-      layer_bounds_(layer_bounds),
+      raster_source_(raster_source),
       resolution_(NON_IDEAL_RESOLUTION),
       tiling_data_(gfx::Size(), gfx::Size(), kBorderTexels),
       last_impl_frame_time_in_seconds_(0.0),
       can_require_tiles_for_activation_(false),
       current_content_to_screen_scale_(0.f),
       has_visible_rect_tiles_(false),
       has_skewport_rect_tiles_(false),
       has_soon_border_rect_tiles_(false),
       has_eventually_rect_tiles_(false) {
-  gfx::Size content_bounds =
-      gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
+  DCHECK(!raster_source->IsSolidColor());
+  gfx::Size content_bounds = gfx::ToCeiledSize(
+      gfx::ScaleSize(raster_source_->GetSize(), contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
-  if (tile_size.IsEmpty()) {
-    layer_bounds_ = gfx::Size();
-    content_bounds = gfx::Size();
-  }
 
-  DCHECK(!gfx::ToFlooredSize(
-      gfx::ScaleSize(layer_bounds, contents_scale)).IsEmpty()) <<
-      "Tiling created with scale too small as contents become empty." <<
-      " Layer bounds: " << layer_bounds.ToString() <<
-      " Contents scale: " << contents_scale;
+  DCHECK(!gfx::ToFlooredSize(gfx::ScaleSize(raster_source_->GetSize(),
+                                            contents_scale)).IsEmpty())
+      << "Tiling created with scale too small as contents become empty."
+      << " Layer bounds: " << raster_source_->GetSize().ToString()
+      << " Contents scale: " << contents_scale;
 
   tiling_data_.SetTilingSize(content_bounds);
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_shared(false);
 }
 
@@ skipping 23 matching lines @@
         DCHECK(!candidate_tile->is_shared());
         DCHECK_EQ(i, candidate_tile->tiling_i_index());
         DCHECK_EQ(j, candidate_tile->tiling_j_index());
         candidate_tile->set_shared(true);
         tiles_[key] = candidate_tile;
         return candidate_tile;
       }
     }
   }
 
+  if (!raster_source_->CoversRect(tile_rect, contents_scale_))
+    return nullptr;
+
   // Create a new tile because our twin didn't have a valid one.
-  scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
-  if (tile.get()) {
-    DCHECK(!tile->is_shared());
-    tile->set_tiling_index(i, j);
-    tiles_[key] = tile;
+  scoped_refptr<Tile> tile = client_->CreateTile(contents_scale_, tile_rect);
+  DCHECK(!tile->is_shared());
+  tile->set_tiling_index(i, j);
+  tiles_[key] = tile;
 
-    if (recycled_twin) {
-      DCHECK(recycled_twin->tiles_.find(key) == recycled_twin->tiles_.end());
-      // Do what recycled_twin->CreateTile() would do.
-      tile->set_shared(true);
-      recycled_twin->tiles_[key] = tile;
-    }
+  if (recycled_twin) {
+    DCHECK(recycled_twin->tiles_.find(key) == recycled_twin->tiles_.end());
+    // Do what recycled_twin->CreateTile() would do.
+    tile->set_shared(true);
+    recycled_twin->tiles_[key] = tile;
   }
   return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
   // There is no recycled twin during commit from the main thread which is when
   // this occurs.
   PictureLayerTiling* null_recycled_twin = nullptr;
@@ skipping 10 matching lines @@
     CreateTile(key.first, key.second, twin_tiling, null_recycled_twin);
   }
 
   VerifyLiveTilesRect(false);
 }
 
 void PictureLayerTiling::CloneTilesAndPropertiesFrom(
     const PictureLayerTiling& twin_tiling) {
   DCHECK_EQ(&twin_tiling, client_->GetPendingOrActiveTwinTiling(this));
 
-  Resize(twin_tiling.layer_bounds_);
+  SetRasterSourceAndResize(twin_tiling.raster_source_);
   DCHECK_EQ(twin_tiling.contents_scale_, contents_scale_);
-  DCHECK_EQ(twin_tiling.layer_bounds().ToString(), layer_bounds().ToString());
+  DCHECK_EQ(twin_tiling.raster_source_, raster_source_);
   DCHECK_EQ(twin_tiling.tile_size().ToString(), tile_size().ToString());
 
   resolution_ = twin_tiling.resolution_;
 
   SetLiveTilesRect(twin_tiling.live_tiles_rect());
 
   // Recreate unshared tiles.
   std::vector<TileMapKey> to_remove;
   for (const auto& tile_map_pair : tiles_) {
     TileMapKey key = tile_map_pair.first;
@@ skipping 26 matching lines @@
 #endif
 
   UpdateTilePriorityRects(twin_tiling.current_content_to_screen_scale_,
                           twin_tiling.current_visible_rect_,
                           twin_tiling.current_skewport_rect_,
                           twin_tiling.current_soon_border_rect_,
                           twin_tiling.current_eventually_rect_,
                           twin_tiling.current_occlusion_in_layer_space_);
 }
 
-void PictureLayerTiling::Resize(const gfx::Size& new_layer_bounds) {
-  gfx::Size layer_bounds = new_layer_bounds;
+void PictureLayerTiling::SetRasterSourceAndResize(
+    scoped_refptr<RasterSource> raster_source) {
+  DCHECK(!raster_source->IsSolidColor());
+  gfx::Size old_layer_bounds = raster_source_->GetSize();
+  raster_source_.swap(raster_source);
+  gfx::Size new_layer_bounds = raster_source_->GetSize();
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(new_layer_bounds, contents_scale_));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
-  if (tile_size.IsEmpty()) {
-    layer_bounds = gfx::Size();
-    content_bounds = gfx::Size();
-  }
-
-  // The layer bounds are only allowed to be empty when the tile size is empty.
-  // Otherwise we should not have such a tiling in the first place.
-  DCHECK_IMPLIES(!tile_size.IsEmpty(), !layer_bounds_.IsEmpty());
-
-  bool resized = layer_bounds != layer_bounds_;
-  layer_bounds_ = layer_bounds;
-
   if (tile_size != tiling_data_.max_texture_size()) {
     tiling_data_.SetTilingSize(content_bounds);
     tiling_data_.SetMaxTextureSize(tile_size);
     // When the tile size changes, the TilingData positions no longer work
     // as valid keys to the TileMap, so just drop all tiles and clear the live
     // tiles rect.
     Reset();
     return;
   }
 
-  if (!resized)
+  if (old_layer_bounds == new_layer_bounds)
     return;
 
   // The SetLiveTilesRect() method would drop tiles outside the new bounds,
   // but may do so incorrectly if resizing the tiling causes the number of
   // tiles in the tiling_data_ to change.
   gfx::Rect content_rect(content_bounds);
   int before_left = tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.x());
   int before_top = tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.y());
   int before_right =
       tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
@@ skipping 90 matching lines @@
     const PictureLayerTiling* null_twin_tiling = nullptr;
     PictureLayerTiling* null_recycled_twin = nullptr;
     DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
     for (size_t i = 0; i < new_tile_keys.size(); ++i) {
       CreateTile(new_tile_keys[i].first, new_tile_keys[i].second,
                  null_twin_tiling, null_recycled_twin);
     }
   }
 }
 
-void PictureLayerTiling::SetRasterSource(
-    scoped_refptr<RasterSource> raster_source) {
+void PictureLayerTiling::SetRasterSourceOnTiles() {
   // Shared (ie. non-invalidated) tiles on the pending tree are updated to use
   // the new raster source. When this raster source is activated, the raster
   // source will remain valid for shared tiles in the active tree.
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    it->second->set_raster_source(raster_source);
+    it->second->set_raster_source(raster_source_);
   VerifyLiveTilesRect(false);
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
@@ skipping 204 matching lines @@
                  extrapolation_multiplier * (old_bottom - new_bottom));
 
   // Clip the skewport to |max_skewport|.
   skewport.Intersect(max_skewport);
 
   // Finally, ensure that visible rect is contained in the skewport.
   skewport.Union(visible_rect_in_content_space);
   return skewport;
 }
 
-void PictureLayerTiling::ComputeTilePriorityRects(
+bool PictureLayerTiling::ComputeTilePriorityRects(
     const gfx::Rect& viewport_in_layer_space,
     float ideal_contents_scale,
     double current_frame_time_in_seconds,
     const Occlusion& occlusion_in_layer_space) {
   if (!NeedsUpdateForFrameAtTimeAndViewport(current_frame_time_in_seconds,
                                             viewport_in_layer_space)) {
     // This should never be zero for the purposes of has_ever_been_updated().
     DCHECK_NE(current_frame_time_in_seconds, 0.0);
-    return;
+    return false;
   }
 
   gfx::Rect visible_rect_in_content_space =
       gfx::ScaleToEnclosingRect(viewport_in_layer_space, contents_scale_);
 
   if (tiling_size().IsEmpty()) {
     last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
     last_viewport_in_layer_space_ = viewport_in_layer_space;
     last_visible_rect_in_content_space_ = visible_rect_in_content_space;
-    return;
+    return false;
   }
 
   // Calculate the skewport.
   gfx::Rect skewport = ComputeSkewport(current_frame_time_in_seconds,
                                        visible_rect_in_content_space);
   DCHECK(skewport.Contains(visible_rect_in_content_space));
 
   // Calculate the eventually/live tiles rect.
   gfx::Size tile_size = tiling_data_.max_texture_size();
   int64 eventually_rect_area =
@@ skipping 17 matching lines @@
   soon_border_rect.Inset(-border, -border, -border, -border);
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_viewport_in_layer_space_ = viewport_in_layer_space;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
   SetLiveTilesRect(eventually_rect);
   UpdateTilePriorityRects(
       content_to_screen_scale, visible_rect_in_content_space, skewport,
       soon_border_rect, eventually_rect, occlusion_in_layer_space);
+  return true;
 }
 
 void PictureLayerTiling::UpdateTilePriorityRects(
     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) {
   current_visible_rect_ = visible_rect_in_content_space;
@@ skipping 121 matching lines @@
     return false;
 
   if (client_->RequiresHighResToDraw())
     return true;
 
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
   if (!twin_tiling)
     return true;
 
-  if (twin_tiling->layer_bounds() != layer_bounds())
+  if (twin_tiling->raster_source()->GetSize() != raster_source()->GetSize())
     return true;
 
   if (twin_tiling->current_visible_rect_ != current_visible_rect_)
     return true;
 
   Tile* twin_tile =
       twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());
   // If twin tile is missing, it might not have a recording, so we don't need
   // this tile to be required for activation.
   if (!twin_tile)
@@ skipping 387 matching lines @@
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 }  // namespace cc