Update from https://crrev.com/304121

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 53 matching lines @@
                              PictureLayerImpl* pending_layer)
     : active(active_layer), pending(pending_layer) {
 }
 
 PictureLayerImpl::Pair::~Pair() {
 }
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
       twin_layer_(nullptr),
-      pile_(PicturePileImpl::Create()),
+      raster_source_(PicturePileImpl::Create()),
       ideal_page_scale_(0.f),
       ideal_device_scale_(0.f),
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       raster_source_scale_is_fixed_(false),
@@ skipping 30 matching lines @@
   // Twin relationships should never change once established.
   DCHECK_IMPLIES(twin_layer_, twin_layer_ == layer_impl);
   DCHECK_IMPLIES(twin_layer_, layer_impl->twin_layer_ == this);
   // The twin relationship does not need to exist before the first
   // PushPropertiesTo from pending to active layer since before that the active
   // layer can not have a pile or tilings, it has only been created and inserted
   // into the tree at that point.
   twin_layer_ = layer_impl;
   layer_impl->twin_layer_ = this;
 
-  layer_impl->UpdatePile(pile_);
+  layer_impl->UpdateRasterSource(raster_source_);
 
-  DCHECK(!pile_->is_solid_color() || !tilings_->num_tilings());
+  DCHECK(!raster_source_->IsSolidColor() || !tilings_->num_tilings());
   // Tilings would be expensive to push, so we swap.
   layer_impl->tilings_.swap(tilings_);
   layer_impl->tilings_->SetClient(layer_impl);
   if (tilings_)
     tilings_->SetClient(this);
 
   // Ensure that the recycle tree doesn't have any unshared tiles.
-  if (tilings_ && pile_->is_solid_color())
+  if (tilings_ && raster_source_->IsSolidColor())
     tilings_->RemoveAllTilings();
 
   // Remove invalidated tiles from what will become a recycle tree.
   if (tilings_)
     tilings_->RemoveTilesInRegion(invalidation_);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
   layer_impl->needs_post_commit_initialization_ = false;
 
   // The invalidation on this soon-to-be-recycled layer must be cleared to
   // mirror clearing the invalidation in PictureLayer's version of this function
   // in case push properties is skipped.
   layer_impl->invalidation_.Swap(&invalidation_);
   invalidation_.Clear();
   needs_post_commit_initialization_ = true;
 
   // We always need to push properties.
   // See http://crbug.com/303943
   needs_push_properties_ = true;
 }
 
-void PictureLayerImpl::UpdatePile(scoped_refptr<PicturePileImpl> pile) {
+void PictureLayerImpl::UpdateRasterSource(
+    scoped_refptr<RasterSource> raster_source) {
   bool could_have_tilings = CanHaveTilings();
-  pile_.swap(pile);
+  raster_source_.swap(raster_source);
 
   // Need to call UpdateTiles again if CanHaveTilings changed.
   if (could_have_tilings != CanHaveTilings()) {
     layer_tree_impl()->set_needs_update_draw_properties();
   }
 }
 
 void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
                                    const Occlusion& occlusion_in_content_space,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
-  DCHECK_IMPLIES(!pile_->tiling_size().IsEmpty(),
-                 bounds() == pile_->tiling_size())
+  DCHECK_IMPLIES(!raster_source_->GetSize().IsEmpty(),
+                 bounds() == raster_source_->GetSize())
       << " bounds " << bounds().ToString() << " pile "
-      << pile_->tiling_size().ToString();
+      << raster_source_->GetSize().ToString();
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
 
-  if (pile_->is_solid_color()) {
+  if (raster_source_->IsSolidColor()) {
     PopulateSharedQuadState(shared_quad_state);
 
     AppendDebugBorderQuad(
         render_pass, bounds(), shared_quad_state, append_quads_data);
 
-    SolidColorLayerImpl::AppendSolidQuads(render_pass,
-                                          occlusion_in_content_space,
-                                          shared_quad_state,
-                                          visible_content_rect(),
-                                          pile_->solid_color(),
-                                          append_quads_data);
+    SolidColorLayerImpl::AppendSolidQuads(
+        render_pass, occlusion_in_content_space, shared_quad_state,
+        visible_content_rect(), raster_source_->GetSolidColor(),
+        append_quads_data);
     return;
   }
 
   float max_contents_scale = MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
   gfx::Size scaled_content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(bounds(), max_contents_scale));
   gfx::Rect scaled_visible_content_rect =
       gfx::ScaleToEnclosingRect(visible_content_rect(), max_contents_scale);
   scaled_visible_content_rect.Intersect(gfx::Rect(scaled_content_bounds));
   Occlusion scaled_occlusion =
       occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
           scaled_draw_transform);
 
-  shared_quad_state->SetAll(scaled_draw_transform,
-                            scaled_content_bounds,
-                            scaled_visible_content_rect,
-                            draw_properties().clip_rect,
-                            draw_properties().is_clipped,
-                            draw_properties().opacity,
-                            blend_mode(),
-                            sorting_context_id_);
+  shared_quad_state->SetAll(
+      scaled_draw_transform, scaled_content_bounds, scaled_visible_content_rect,
+      draw_properties().clip_rect, draw_properties().is_clipped,
+      draw_properties().opacity, draw_properties().blend_mode,
+      sorting_context_id_);
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
         render_pass,
         scaled_content_bounds,
         shared_quad_state,
         append_quads_data,
         DebugColors::DirectPictureBorderColor(),
         DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
 
     gfx::Rect geometry_rect = scaled_visible_content_rect;
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Rect visible_geometry_rect =
         scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
     if (visible_geometry_rect.IsEmpty())
       return;
 
     gfx::Size texture_size = scaled_visible_content_rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = scaled_visible_content_rect;
 
     PictureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
-    quad->SetNew(shared_quad_state,
-                 geometry_rect,
-                 opaque_rect,
-                 visible_geometry_rect,
-                 texture_rect,
-                 texture_size,
-                 RGBA_8888,
-                 quad_content_rect,
-                 max_contents_scale,
-                 pile_);
+    quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
+                 visible_geometry_rect, texture_rect, texture_size, RGBA_8888,
+                 quad_content_rect, max_contents_scale, raster_source_);
     return;
   }
 
   AppendDebugBorderQuad(
       render_pass, scaled_content_bounds, shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(),
              max_contents_scale,
@@ skipping 111 matching lines @@
           }
 
           gfx::RectF texture_rect = iter.texture_rect();
 
           ResourceProvider* resource_provider =
               layer_tree_impl()->resource_provider();
           ResourceFormat format =
               resource_provider->memory_efficient_texture_format();
           PictureDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
-          quad->SetNew(shared_quad_state,
-                       geometry_rect,
-                       opaque_rect,
-                       visible_geometry_rect,
-                       texture_rect,
-                       iter.texture_size(),
-                       format,
-                       iter->content_rect(),
-                       iter->contents_scale(),
-                       pile_);
+          quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
+                       visible_geometry_rect, texture_rect, iter.texture_size(),
+                       format, iter->content_rect(), iter->contents_scale(),
+                       raster_source_);
           has_draw_quad = true;
           break;
         }
         case ManagedTileState::DrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        visible_geometry_rect,
                        draw_info.get_solid_color(),
@@ skipping 94 matching lines @@
   DCHECK(raster_page_scale_);
   DCHECK(raster_device_scale_);
   DCHECK(raster_source_scale_);
   DCHECK(raster_contents_scale_);
   DCHECK(low_res_raster_contents_scale_);
 
   was_screen_space_transform_animating_ =
       draw_properties().screen_space_transform_is_animating;
 
   if (draw_transform_is_animating())
-    pile_->set_likely_to_be_used_for_transform_animation();
+    raster_source_->SetShouldAttemptToUseDistanceFieldText();
 
   should_update_tile_priorities_ = true;
 
   UpdateTilePriorities(occlusion_in_content_space);
 }
 
 void PictureLayerImpl::UpdateTilePriorities(
     const Occlusion& occlusion_in_content_space) {
-  DCHECK(!pile_->is_solid_color() || !tilings_->num_tilings());
+  DCHECK(!raster_source_->IsSolidColor() || !tilings_->num_tilings());
   double current_frame_time_in_seconds =
       (layer_tree_impl()->CurrentBeginFrameArgs().frame_time -
        base::TimeTicks()).InSecondsF();
 
   gfx::Rect viewport_rect_in_layer_space =
       GetViewportForTilePriorityInContentSpace();
   bool tiling_needs_update = false;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     if (tilings_->tiling_at(i)->NeedsUpdateForFrameAtTimeAndViewport(
             current_frame_time_in_seconds, viewport_rect_in_layer_space)) {
@@ skipping 71 matching lines @@
   }
 }
 
 void PictureLayerImpl::DidBecomeActive() {
   LayerImpl::DidBecomeActive();
   // TODO(vmpstr): See if this can be removed in favour of calling it from LTHI
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 void PictureLayerImpl::DidBeginTracing() {
-  pile_->DidBeginTracing();
+  raster_source_->DidBeginTracing();
 }
 
 void PictureLayerImpl::ReleaseResources() {
   if (tilings_)
     RemoveAllTilings();
 
   ResetRasterScale();
 
   // To avoid an edge case after lost context where the tree is up to date but
   // the tilings have not been managed, request an update draw properties
   // to force tilings to get managed.
   layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 skia::RefPtr<SkPicture> PictureLayerImpl::GetPicture() {
-  return pile_->GetFlattenedPicture();
+  return raster_source_->GetFlattenedPicture();
 }
 
 scoped_refptr<Tile> PictureLayerImpl::CreateTile(PictureLayerTiling* tiling,
                                                const gfx::Rect& content_rect) {
-  DCHECK(!pile_->is_solid_color());
-  if (!pile_->CanRaster(tiling->contents_scale(), content_rect))
+  DCHECK(!raster_source_->IsSolidColor());
+  if (!raster_source_->CoversRect(content_rect, tiling->contents_scale()))
     return scoped_refptr<Tile>();
 
   int flags = 0;
 
   // TODO(vmpstr): Revisit this. For now, enabling analysis means that we get as
   // much savings on memory as we can. However, for some cases like ganesh or
   // small layers, the amount of time we spend analyzing might not justify
   // memory savings that we can get. Note that we don't handle solid color
   // masks, so we shouldn't bother analyzing those.
   // Bugs: crbug.com/397198, crbug.com/396908
-  if (!pile_->is_mask())
+  if (!raster_source_->IsMask())
     flags = Tile::USE_PICTURE_ANALYSIS;
 
   return layer_tree_impl()->tile_manager()->CreateTile(
-      pile_.get(),
-      content_rect.size(),
-      content_rect,
-      tiling->contents_scale(),
-      id(),
-      layer_tree_impl()->source_frame_number(),
+      raster_source_.get(), content_rect.size(), content_rect,
+      tiling->contents_scale(), id(), layer_tree_impl()->source_frame_number(),
       flags);
 }
 
 RasterSource* PictureLayerImpl::GetRasterSource() {
-  return pile_.get();
+  return raster_source_.get();
 }
 
 const Region* PictureLayerImpl::GetPendingInvalidation() {
   if (layer_tree_impl()->IsPendingTree())
     return &invalidation_;
   DCHECK(layer_tree_impl()->IsActiveTree());
   if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     return &twin_layer->invalidation_;
   return nullptr;
 }
@@ skipping 10 matching lines @@
 }
 
 PictureLayerTiling* PictureLayerImpl::GetRecycledTwinTiling(
     const PictureLayerTiling* tiling) {
   PictureLayerImpl* recycled_twin = GetRecycledTwinLayer();
   if (!recycled_twin || !recycled_twin->tilings_)
     return nullptr;
   return recycled_twin->tilings_->TilingAtScale(tiling->contents_scale());
 }
 
+TilePriority::PriorityBin PictureLayerImpl::GetMaxTilePriorityBin() const {
+  if (!HasValidTilePriorities())
+    return TilePriority::EVENTUALLY;
+  return TilePriority::NOW;
+}
+
 size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
   return layer_tree_impl()->settings().max_tiles_for_interest_area;
 }
 
 float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
   float skewport_target_time_in_frames =
       layer_tree_impl()->use_gpu_rasterization()
           ? kGpuSkewportTargetTimeInFrames
           : kCpuSkewportTargetTimeInFrames;
   return skewport_target_time_in_frames *
          layer_tree_impl()->begin_impl_frame_interval().InSecondsF() *
          layer_tree_impl()->settings().skewport_target_time_multiplier;
 }
 
 int PictureLayerImpl::GetSkewportExtrapolationLimitInContentPixels() const {
   return layer_tree_impl()
       ->settings()
       .skewport_extrapolation_limit_in_content_pixels;
 }
 
 bool PictureLayerImpl::RequiresHighResToDraw() const {
   return layer_tree_impl()->RequiresHighResToDraw();
 }
 
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   int max_texture_size =
       layer_tree_impl()->resource_provider()->max_texture_size();
 
-  if (pile_->is_mask()) {
+  if (raster_source_->IsMask()) {
     // Masks are not tiled, so if we can't cover the whole mask with one tile,
     // don't make any tiles at all. Returning an empty size signals this.
     if (content_bounds.width() > max_texture_size ||
         content_bounds.height() > max_texture_size)
       return gfx::Size();
     return content_bounds;
   }
 
   int default_tile_width = 0;
   int default_tile_height = 0;
@@ skipping 68 matching lines @@
   }
 
   raster_page_scale_ = other->raster_page_scale_;
   raster_device_scale_ = other->raster_device_scale_;
   raster_source_scale_ = other->raster_source_scale_;
   raster_contents_scale_ = other->raster_contents_scale_;
   low_res_raster_contents_scale_ = other->low_res_raster_contents_scale_;
 
   bool synced_high_res_tiling = false;
   if (CanHaveTilings()) {
-    synced_high_res_tiling = tilings_->SyncTilings(*other->tilings_,
-                                                   pile_->tiling_size(),
-                                                   invalidation_,
-                                                   MinimumContentsScale());
+    synced_high_res_tiling =
+        tilings_->SyncTilings(*other->tilings_, raster_source_->GetSize(),
+                              invalidation_, MinimumContentsScale());
   } else {
     RemoveAllTilings();
   }
 
   // If our MinimumContentsScale has changed to prevent the twin's high res
   // tiling from being synced, we should reset the raster scale and let it be
   // recalculated (1) again. This can happen if our bounds shrink to the point
   // where min contents scale grows.
   // (1) - TODO(vmpstr) Instead of hoping that this will be recalculated, we
   // should refactor this code a little bit and actually recalculate this.
   // However, this is a larger undertaking, so this will work for now.
   if (!synced_high_res_tiling)
     ResetRasterScale();
   else
     SanityCheckTilingState();
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
   if (!tilings_)
     return;
   if (!CanHaveTilingWithScale(tiling->contents_scale()))
     return;
-  tilings_->AddTiling(tiling->contents_scale(), pile_->tiling_size());
+  tilings_->AddTiling(tiling->contents_scale(), raster_source_->GetSize());
 
   // If this tree needs update draw properties, then the tiling will
   // get updated prior to drawing or activation.  If this tree does not
   // need update draw properties, then its transforms are up to date and
   // we can create tiles for this tiling immediately.
   if (!layer_tree_impl()->needs_update_draw_properties() &&
       should_update_tile_priorities_) {
     // TODO(danakj): Add a DCHECK() that we are not using occlusion tracking
     // when we stop using the pending tree in the browser compositor. If we want
     // to support occlusion tracking here, we need to dirty the draw properties
     // or save occlusion as a draw property.
     UpdateTilePriorities(Occlusion());
   }
 }
 
 void PictureLayerImpl::GetContentsResourceId(
     ResourceProvider::ResourceId* resource_id,
     gfx::Size* resource_size) const {
-  DCHECK_EQ(bounds().ToString(), pile_->tiling_size().ToString());
+  DCHECK_EQ(bounds().ToString(), raster_source_->GetSize().ToString());
   gfx::Rect content_rect(bounds());
   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), 1.f, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
   if (!iter || !*iter) {
     *resource_id = 0;
     return;
   }
 
@@ skipping 29 matching lines @@
   }
 
   needs_post_commit_initialization_ = false;
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(CanHaveTilingWithScale(contents_scale)) <<
       "contents_scale: " << contents_scale;
 
   PictureLayerTiling* tiling =
-      tilings_->AddTiling(contents_scale, pile_->tiling_size());
+      tilings_->AddTiling(contents_scale, raster_source_->GetSize());
 
-  DCHECK(pile_->HasRecordings());
+  DCHECK(raster_source_->HasRecordings());
 
   if (PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer())
     twin_layer->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   if (!tilings_ || tilings_->num_tilings() == 0)
     return;
@@ skipping 178 matching lines @@
       !ShouldAdjustRasterScaleDuringScaleAnimations()) {
     bool can_raster_at_maximum_scale = false;
     // TODO(ajuma): If we need to deal with scale-down animations starting right
     // as a layer gets promoted, then we'd want to have the
     // |starting_animation_contents_scale| passed in here as a separate draw
     // property so we could try use that when the max is too large.
     // See crbug.com/422341.
     float maximum_scale = draw_properties().maximum_animation_contents_scale;
     if (maximum_scale) {
       gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(
-          gfx::ScaleSize(pile_->tiling_size(), maximum_scale));
+          gfx::ScaleSize(raster_source_->GetSize(), maximum_scale));
       if (bounds_at_maximum_scale.GetArea() <=
           layer_tree_impl()->device_viewport_size().GetArea())
         can_raster_at_maximum_scale = true;
     }
     // Use the computed scales for the raster scale directly, do not try to use
     // the ideal scale here. The current ideal scale may be way too large in the
     // case of an animation with scale, and will be constantly changing.
     if (can_raster_at_maximum_scale)
       raster_contents_scale_ = maximum_scale;
     else
       raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
 
   // If this layer would create zero or one tiles at this content scale,
   // don't create a low res tiling.
   gfx::Size raster_bounds = gfx::ToCeiledSize(
-      gfx::ScaleSize(pile_->tiling_size(), raster_contents_scale_));
+      gfx::ScaleSize(raster_source_->GetSize(), raster_contents_scale_));
   gfx::Size tile_size = CalculateTileSize(raster_bounds);
   bool tile_covers_bounds = tile_size.width() >= raster_bounds.width() &&
                             tile_size.height() >= raster_bounds.height();
   if (tile_size.IsEmpty() || tile_covers_bounds) {
     low_res_raster_contents_scale_ = raster_contents_scale_;
     return;
   }
 
   float low_res_factor =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
@@ skipping 86 matching lines @@
   SanityCheckTilingState();
 }
 
 float PictureLayerImpl::MinimumContentsScale() const {
   float setting_min = layer_tree_impl()->settings().minimum_contents_scale;
 
   // If the contents scale is less than 1 / width (also for height),
   // then it will end up having less than one pixel of content in that
   // dimension.  Bump the minimum contents scale up in this case to prevent
   // this from happening.
-  int min_dimension =
-      std::min(pile_->tiling_size().width(), pile_->tiling_size().height());
+  int min_dimension = std::min(raster_source_->GetSize().width(),
+                               raster_source_->GetSize().height());
   if (!min_dimension)
     return setting_min;
 
   return std::max(1.f / min_dimension, setting_min);
 }
 
 void PictureLayerImpl::ResetRasterScale() {
   raster_page_scale_ = 0.f;
   raster_device_scale_ = 0.f;
   raster_source_scale_ = 0.f;
   raster_contents_scale_ = 0.f;
   low_res_raster_contents_scale_ = 0.f;
   raster_source_scale_is_fixed_ = false;
 
   // When raster scales aren't valid, don't update tile priorities until
   // this layer has been updated via UpdateDrawProperties.
   should_update_tile_priorities_ = false;
 }
 
 bool PictureLayerImpl::CanHaveTilings() const {
-  if (pile_->is_solid_color())
+  if (raster_source_->IsSolidColor())
     return false;
   if (!DrawsContent())
     return false;
-  if (!pile_->HasRecordings())
+  if (!raster_source_->HasRecordings())
     return false;
   return true;
 }
 
 bool PictureLayerImpl::CanHaveTilingWithScale(float contents_scale) const {
   if (!CanHaveTilings())
     return false;
   if (contents_scale < MinimumContentsScale())
     return false;
   return true;
@@ skipping 79 matching lines @@
 
   state->BeginArray("tile_priority_rect");
   MathUtil::AddToTracedValue(GetViewportForTilePriorityInContentSpace(), state);
   state->EndArray();
 
   state->BeginArray("visible_rect");
   MathUtil::AddToTracedValue(visible_content_rect(), state);
   state->EndArray();
 
   state->BeginArray("pictures");
-  pile_->AsValueInto(state);
+  raster_source_->AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("invalidation");
   invalidation_.AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("coverage_tiles");
   for (PictureLayerTilingSet::CoverageIterator iter(
-           tilings_.get(),
-           1.f,
-           gfx::Rect(pile_->tiling_size()),
+           tilings_.get(), 1.f, gfx::Rect(raster_source_->GetSize()),
            ideal_contents_scale_);
-       iter;
-       ++iter) {
+       iter; ++iter) {
     state->BeginDictionary();
 
     state->BeginArray("geometry_rect");
     MathUtil::AddToTracedValue(iter.geometry_rect(), state);
     state->EndArray();
 
     if (*iter)
       TracedValue::SetIDRef(*iter, state, "tile");
 
     state->EndDictionary();
@@ skipping 15 matching lines @@
 }
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
-bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
-  if (!layer_tree_impl()->IsPendingTree())
-    return true;
-
+bool PictureLayerImpl::AllTilesRequiredAreReadyToDraw(
+    TileRequirementCheck is_tile_required_callback) const {
   if (!HasValidTilePriorities())
     return true;
 
   if (!tilings_)
     return true;
 
   if (visible_rect_for_tile_priority_.IsEmpty())
     return true;
 
   gfx::Rect rect = GetViewportForTilePriorityInContentSpace();
@@ skipping 11 matching lines @@
       // A null tile (i.e. missing recording) can just be skipped.
       // TODO(vmpstr): Verify this is true if we create tiles in raster
       // iterators.
       if (!tile)
         continue;
 
       // We can't check tile->required_for_activation, because that value might
       // be out of date. It is updated in the raster/eviction iterators.
       // TODO(vmpstr): Remove the comment once you can't access this information
       // from the tile.
-      if (tiling->IsTileRequiredForActivation(tile) && !tile->IsReadyToDraw()) {
-        TRACE_EVENT_INSTANT0("cc",
-                             "PictureLayerImpl::"
-                             "AllTilesRequiredForActivationAreReadyToDraw not "
-                             "ready to activate",
+      if ((tiling->*is_tile_required_callback)(tile) &&
+          !tile->IsReadyToDraw()) {
+        TRACE_EVENT_INSTANT0("cc", "Tile required, but not ready to draw.",
                              TRACE_EVENT_SCOPE_THREAD);
         return false;
       }
     }
   }
 
   return true;
 }
 
+bool PictureLayerImpl::AllTilesRequiredForActivationAreReadyToDraw() const {
+  if (!layer_tree_impl()->IsPendingTree())
+    return true;
+
+  return AllTilesRequiredAreReadyToDraw(
+      &PictureLayerTiling::IsTileRequiredForActivationIfVisible);
+}
+
+bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
+  if (!layer_tree_impl()->IsActiveTree())
+    return true;
+
+  return AllTilesRequiredAreReadyToDraw(
+      &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
+}
+
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator()
     : layer_(nullptr), current_stage_(arraysize(stages_)) {
 }
 
 PictureLayerImpl::LayerRasterTileIterator::LayerRasterTileIterator(
     PictureLayerImpl* layer,
     bool prioritize_low_res)
     : layer_(layer), current_stage_(0) {
   DCHECK(layer_);
 
@@ skipping 114 matching lines @@
       current_tiling_(0u) {
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
     PictureLayerImpl* layer,
     TreePriority tree_priority)
     : layer_(layer),
       tree_priority_(tree_priority),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
-      current_tiling_(CurrentTilingRange().start - 1u) {
-  // TODO(vmpstr): Once tile priorities are determined by the iterators, ensure
-  // that layers that don't have valid tile priorities have lowest priorities so
-  // they evict their tiles first (crbug.com/381704)
-  DCHECK(layer_->tilings_);
+      current_tiling_(0u) {
+  // Early out if the layer has no tilings.
+  if (!layer_->tilings_ || !layer_->tilings_->num_tilings())
+    return;
+
+  current_tiling_ = CurrentTilingRange().start - 1u;
   do {
     if (!AdvanceToNextTiling())
       break;
 
     current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
         layer_->tilings_->tiling_at(CurrentTilingIndex()),
         tree_priority,
         current_category_);
   } while (!current_iterator_);
 }
@@ skipping 114 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc