Cache viewport rect for tile priority in UpdateTiles

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 <cmath>
 #include <limits>
 #include <set>
@@ skipping 265 matching lines @@
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   // Ignore missing tiles outside of viewport for tile priority. This is
   // normally the same as draw viewport but can be independently overridden by
   // embedders like Android WebView with SetExternalDrawConstraints.
   gfx::Rect scaled_viewport_for_tile_priority = gfx::ScaleToEnclosingRect(
-      GetViewportForTilePriorityInContentSpace(), max_contents_scale);
+      viewport_rect_for_tile_priority_in_content_space_, max_contents_scale);
 
   size_t missing_tile_count = 0u;
   size_t on_demand_missing_tile_count = 0u;
   only_used_low_res_last_append_quads_ = true;
   for (PictureLayerTilingSet::CoverageIterator iter(tilings_.get(),
                                                     max_contents_scale,
                                                     scaled_visible_content_rect,
                                                     ideal_contents_scale_);
        iter;
        ++iter) {
@@ skipping 170 matching lines @@
   return UpdateTilePriorities(occlusion_in_content_space);
 }
 
 bool PictureLayerImpl::UpdateTilePriorities(
     const Occlusion& occlusion_in_content_space) {
   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();
+  UpdateViewportRectForTilePriorityInContentSpace();
 
   // 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();
 
   // 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_,
+      viewport_rect_for_tile_priority_in_content_space_, ideal_contents_scale_,
       current_frame_time_in_seconds, occlusion_in_content_space,
       can_require_tiles_for_activation);
   return updated;
 }
 
-gfx::Rect PictureLayerImpl::GetViewportForTilePriorityInContentSpace() const {
+void PictureLayerImpl::UpdateViewportRectForTilePriorityInContentSpace() {
   // 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();
-
   if (visible_rect_in_content_space.IsEmpty() ||
       layer_tree_impl()->DeviceViewport() != viewport_rect_for_tile_priority) {
     gfx::Transform view_to_layer(gfx::Transform::kSkipInitialization);
     if (screen_space_transform().GetInverse(&view_to_layer)) {
       // Transform from view space to content space.
       visible_rect_in_content_space =
           gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
               view_to_layer, viewport_rect_for_tile_priority));
     }
   }
-  return visible_rect_in_content_space;
+  viewport_rect_for_tile_priority_in_content_space_ =
+      visible_rect_in_content_space;
 }
 
 PictureLayerImpl* PictureLayerImpl::GetPendingOrActiveTwinLayer() const {
   if (!twin_layer_ || !twin_layer_->IsOnActiveOrPendingTree())
     return nullptr;
   return twin_layer_;
 }
 
 PictureLayerImpl* PictureLayerImpl::GetRecycledTwinLayer() const {
   if (!twin_layer_ || twin_layer_->IsOnActiveOrPendingTree())
@@ skipping 638 matching lines @@
 
 void PictureLayerImpl::AsValueInto(base::debug::TracedValue* state) const {
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->SetDouble("geometry_contents_scale", MaximumTilingContentsScale());
   state->BeginArray("tilings");
   tilings_->AsValueInto(state);
   state->EndArray();
 
   MathUtil::AddToTracedValue("tile_priority_rect",
-                             GetViewportForTilePriorityInContentSpace(), state);
-
+                             viewport_rect_for_tile_priority_in_content_space_,
+                             state);
   MathUtil::AddToTracedValue("visible_rect", visible_content_rect(), state);
 
   state->BeginArray("pictures");
   raster_source_->AsValueInto(state);
   state->EndArray();
 
   state->BeginArray("invalidation");
   invalidation_.AsValueInto(state);
   state->EndArray();
 
@@ skipping 38 matching lines @@
     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();
+  gfx::Rect rect = viewport_rect_for_tile_priority_in_content_space_;
   rect.Intersect(visible_rect_for_tile_priority_);
 
   // The high resolution tiling is the only tiling that can mark tiles as
   // requiring either draw or activation. There is an explicit check in those
   // callbacks to return false if they are not high resolution tilings. This
   // check needs to remain since there are other callers of that function that
   // rely on it. However, for the purposes of this function, we don't have to
   // check other tilings.
   PictureLayerTiling* tiling =
       tilings_->FindTilingWithResolution(HIGH_RESOLUTION);
@@ skipping 33 matching lines @@
 
 bool PictureLayerImpl::AllTilesRequiredForDrawAreReadyToDraw() const {
   if (!layer_tree_impl()->IsActiveTree())
     return true;
 
   return AllTilesRequiredAreReadyToDraw(
       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 }
 
 }  // namespace cc