Update from chromium https://crrev.com/304586

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 13 matching lines @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/tile_manager.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace {
+// This must be > 1 as we multiply or divide by this to find a new raster
+// scale during pinch.
 const float kMaxScaleRatioDuringPinch = 2.0f;
 
 // When creating a new tiling during pinch, snap to an existing
 // tiling's scale if the desired scale is within this ratio.
 const float kSnapToExistingTilingRatio = 1.2f;
 
 // Estimate skewport 60 frames ahead for pre-rasterization on the CPU.
 const float kCpuSkewportTargetTimeInFrames = 60.0f;
 
 // Don't pre-rasterize on the GPU (except for kBackflingGuardDistancePixels in
@@ skipping 34 matching lines @@
       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),
       was_screen_space_transform_animating_(false),
       needs_post_commit_initialization_(true),
       should_update_tile_priorities_(false),
-      only_used_low_res_last_append_quads_(false) {
+      only_used_low_res_last_append_quads_(false),
+      is_mask_(false) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (twin_layer_)
     twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
@@ skipping 18 matching lines @@
   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->UpdateRasterSource(raster_source_);
 
-  DCHECK(!raster_source_->IsSolidColor() || !tilings_->num_tilings());
+  DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
   // 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_ && raster_source_->IsSolidColor())
     tilings_->RemoveAllTilings();
 
@@ skipping 327 matching lines @@
     ideal_page_scale_ = 0.f;
     ideal_device_scale_ = 0.f;
     ideal_contents_scale_ = 0.f;
     ideal_source_scale_ = 0.f;
     SanityCheckTilingState();
     return;
   }
 
   UpdateIdealScales();
 
-  DCHECK(tilings_->num_tilings() > 0 || raster_contents_scale_ == 0.f)
+  DCHECK_IMPLIES(tilings_->num_tilings() == 0, raster_contents_scale_ == 0.f)
       << "A layer with no tilings shouldn't have valid raster scales";
   if (!raster_contents_scale_ || ShouldAdjustRasterScale()) {
     RecalculateRasterScales();
     AddTilingsForRasterScale();
   }
 
   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())
     raster_source_->SetShouldAttemptToUseDistanceFieldText();
 
   should_update_tile_priorities_ = true;
 
   UpdateTilePriorities(occlusion_in_content_space);
 }
 
 void PictureLayerImpl::UpdateTilePriorities(
     const Occlusion& occlusion_in_content_space) {
-  DCHECK(!raster_source_->IsSolidColor() || !tilings_->num_tilings());
+  DCHECK_IMPLIES(raster_source_->IsSolidColor(), tilings_->num_tilings() == 0);
+
   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)) {
-      tiling_needs_update = true;
-      break;
-    }
-  }
-  if (!tiling_needs_update)
-    return;
 
-  WhichTree tree =
-      layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
+  // The tiling set can require tiles for activation any of the following
+  // conditions are true:
+  // - This layer produced a high-res or non-ideal-res tile last frame.
+  // - We're in requires high res to draw mode.
+  // - We're not in smoothness takes priority mode.
+  // To put different, the tiling set can't require tiles for activation if
+  // we're in smoothness mode and only used low-res or checkerboard to draw last
+  // frame and we don't need high res to draw.
+  //
+  // The reason for this is that we should be able to activate sooner and get a
+  // more up to date recording, so we don't run out of recording on the active
+  // tree.
   bool can_require_tiles_for_activation =
       !only_used_low_res_last_append_quads_ || RequiresHighResToDraw() ||
       !layer_tree_impl()->SmoothnessTakesPriority();
-  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
-    tiling->set_can_require_tiles_for_activation(
-        can_require_tiles_for_activation);
+  // Pass |occlusion_in_content_space| for |occlusion_in_layer_space| since
+  // they are the same space in picture layer, as contents scale is always 1.
+  bool updated = tilings_->UpdateTilePriorities(
+      viewport_rect_in_layer_space, ideal_contents_scale_,
+      current_frame_time_in_seconds, occlusion_in_content_space,
+      can_require_tiles_for_activation);
 
-    // Pass |occlusion_in_content_space| for |occlusion_in_layer_space| since
-    // they are the same space in picture layer, as contents scale is always 1.
-    tiling->ComputeTilePriorityRects(tree,
-                                     viewport_rect_in_layer_space,
-                                     ideal_contents_scale_,
-                                     current_frame_time_in_seconds,
-                                     occlusion_in_content_space);
-  }
-
-  // Tile priorities were modified.
   // TODO(vmpstr): See if this can be removed in favour of calling it from LTHI
-  layer_tree_impl()->DidModifyTilePriorities();
+  if (updated)
+    layer_tree_impl()->DidModifyTilePriorities();
 }
 
 gfx::Rect PictureLayerImpl::GetViewportForTilePriorityInContentSpace() const {
   // If visible_rect_for_tile_priority_ is empty or
   // viewport_rect_for_tile_priority is set to be different from the device
   // viewport, try to inverse project the viewport into layer space and use
   // that. Otherwise just use visible_rect_for_tile_priority_
   gfx::Rect visible_rect_in_content_space = visible_rect_for_tile_priority_;
   gfx::Rect viewport_rect_for_tile_priority =
       layer_tree_impl()->ViewportRectForTilePriority();
@@ skipping 64 matching lines @@
     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 (!raster_source_->IsMask())
+  if (!is_mask_)
     flags = Tile::USE_PICTURE_ANALYSIS;
 
   return layer_tree_impl()->tile_manager()->CreateTile(
       raster_source_.get(), content_rect.size(), content_rect,
       tiling->contents_scale(), id(), layer_tree_impl()->source_frame_number(),
       flags);
 }
 
-RasterSource* PictureLayerImpl::GetRasterSource() {
-  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;
 }
 
 const PictureLayerTiling* PictureLayerImpl::GetPendingOrActiveTwinTiling(
@@ skipping 43 matching lines @@
 
 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 (raster_source_->IsMask()) {
+  if (is_mask_) {
     // 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_, raster_source_->GetSize(),
-                              invalidation_, MinimumContentsScale());
+    synced_high_res_tiling = tilings_->SyncTilings(
+        *other->tilings_, raster_source_->GetSize(), invalidation_,
+        MinimumContentsScale(), raster_source_.get());
   } 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.
@@ skipping 54 matching lines @@
 
   *resource_id = draw_info.get_resource_id();
   *resource_size = iter.texture_size();
 }
 
 void PictureLayerImpl::DoPostCommitInitialization() {
   DCHECK(needs_post_commit_initialization_);
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!tilings_)
-    tilings_ = make_scoped_ptr(new PictureLayerTilingSet(this));
+    tilings_ = PictureLayerTilingSet::Create(this);
 
   PictureLayerImpl* twin_layer = GetPendingOrActiveTwinLayer();
   if (twin_layer) {
     // If the twin has never been pushed to, do not sync from it.
     // This can happen if this function is called during activation.
     if (!twin_layer->needs_post_commit_initialization_)
       SyncFromActiveLayer(twin_layer);
   }
 
   needs_post_commit_initialization_ = false;
@@ skipping 166 matching lines @@
   // a throttled rate. Possibly make use of invalidation_.IsEmpty() on pending
   // tree. This will allow CSS scale changes to get re-rastered at an
   // appropriate rate. (crbug.com/413636)
   if (raster_source_scale_is_fixed_) {
     raster_contents_scale_ /= raster_source_scale_;
     raster_source_scale_ = 1.f;
   }
 
   // During pinch we completely ignore the current ideal scale, and just use
   // a multiple of the previous scale.
-  // TODO(danakj): This seems crazy, we should use the current ideal, no?
   bool is_pinching = layer_tree_impl()->PinchGestureActive();
   if (is_pinching && old_raster_contents_scale) {
     // See ShouldAdjustRasterScale:
     // - When zooming out, preemptively create new tiling at lower resolution.
     // - When zooming in, approximate ideal using multiple of kMaxScaleRatio.
     bool zooming_out = old_raster_page_scale > ideal_page_scale_;
-    float desired_contents_scale =
-        zooming_out ? old_raster_contents_scale / kMaxScaleRatioDuringPinch
-                    : old_raster_contents_scale * kMaxScaleRatioDuringPinch;
+    float desired_contents_scale = old_raster_contents_scale;
+    if (zooming_out) {
+      while (desired_contents_scale > ideal_contents_scale_)
+        desired_contents_scale /= kMaxScaleRatioDuringPinch;
+    } else {
+      while (desired_contents_scale < ideal_contents_scale_)
+        desired_contents_scale *= kMaxScaleRatioDuringPinch;
+    }
     raster_contents_scale_ = SnappedContentsScale(desired_contents_scale);
     raster_page_scale_ =
         raster_contents_scale_ / raster_device_scale_ / raster_source_scale_;
   }
 
   // If we're not re-rasterizing during animation, rasterize at the maximum
   // scale that will occur during the animation, if the maximum scale is
   // known. However we want to avoid excessive memory use. If the scale is
   // smaller than what we would choose otherwise, then it's always better off
   // for us memory-wise. But otherwise, we don't choose a scale at which this
@@ skipping 637 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