cc: Simplify picture layer tiling update tile priorities.

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 "base/time/time.h"
@@ skipping 22 matching lines @@
 // tiling's scale if the desired scale is within this ratio.
 const float kSnapToExistingTilingRatio = 0.2f;
 }
 
 namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
       twin_layer_(NULL),
       pile_(PicturePileImpl::Create()),
-      last_content_scale_(0),
       is_mask_(false),
       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),
@@ skipping 273 matching lines @@
             current_frame_time_in_seconds)) {
       tiling_needs_update = true;
       break;
     }
   }
   if (!tiling_needs_update)
     return;
 
   UpdateLCDTextStatus(can_use_lcd_text());
 
-  gfx::Transform current_screen_space_transform = screen_space_transform();
-
-  gfx::Size viewport_size = layer_tree_impl()->DrawViewportSize();
-  gfx::Rect viewport_in_content_space;
-  gfx::Transform screen_to_layer(gfx::Transform::kSkipInitialization);
-  if (screen_space_transform().GetInverse(&screen_to_layer)) {
-    viewport_in_content_space = MathUtil::ProjectEnclosingClippedRect(
-        screen_to_layer, gfx::Rect(viewport_size));
+  // Use visible_content_rect, unless it's empty. If it's empty, then
+  // try to inverse project the viewport into layer space and use that.
+  gfx::Rect visible_rect_in_content_space = visible_content_rect();
+  if (visible_rect_in_content_space.IsEmpty()) {
+    gfx::Transform screen_to_layer(gfx::Transform::kSkipInitialization);
+    if (screen_space_transform().GetInverse(&screen_to_layer)) {
+      gfx::Size viewport_size = layer_tree_impl()->DrawViewportSize();
+      visible_rect_in_content_space =
+          gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
+              screen_to_layer, gfx::Rect(viewport_size)));
+      visible_rect_in_content_space.Intersect(gfx::Rect(content_bounds()));
+    }
   }
 
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
-  size_t max_tiles_for_interest_area =
-      layer_tree_impl()->settings().max_tiles_for_interest_area;
-  tilings_->UpdateTilePriorities(
-      tree,
-      viewport_size,
-      viewport_in_content_space,
-      visible_content_rect(),
-      last_bounds_,
-      bounds(),
-      last_content_scale_,
-      contents_scale_x(),
-      last_screen_space_transform_,
-      current_screen_space_transform,
-      current_frame_time_in_seconds,
-      max_tiles_for_interest_area);
+
+  tilings_->UpdateTilePriorities(tree,
+                                 visible_rect_in_content_space,
+                                 contents_scale_x(),
+                                 current_frame_time_in_seconds);
 
   if (layer_tree_impl()->IsPendingTree())
     MarkVisibleResourcesAsRequired();
 
-  last_screen_space_transform_ = current_screen_space_transform;
-  last_bounds_ = bounds();
-  last_content_scale_ = contents_scale_x();
-
   // Tile priorities were modified.
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
 void PictureLayerImpl::DidBecomeActive() {
   LayerImpl::DidBecomeActive();
   tilings_->DidBecomeActive();
   layer_tree_impl()->DidModifyTilePriorities();
 }
 
@@ skipping 123 matching lines @@
   if (!twin_layer_ || twin_layer_->should_use_gpu_rasterization() !=
       should_use_gpu_rasterization())
     return NULL;
   for (size_t i = 0; i < twin_layer_->tilings_->num_tilings(); ++i)
     if (twin_layer_->tilings_->tiling_at(i)->contents_scale() ==
         tiling->contents_scale())
       return twin_layer_->tilings_->tiling_at(i);
   return NULL;
 }
 
+size_t PictureLayerImpl::GetMaxTilesForInterestArea() const {
+  return layer_tree_impl()->settings().max_tiles_for_interest_area;
+}
+
+float PictureLayerImpl::GetSkewportTargetTimeInSeconds() const {
+  return layer_tree_impl()->settings().skewport_target_time_in_seconds;
+}
+
+int PictureLayerImpl::GetSkewportExtrapolationLimitInContentPixels() const {
+  return layer_tree_impl()
+      ->settings()
+      .skewport_extrapolation_limit_in_content_pixels;
+}
+
 gfx::Size PictureLayerImpl::CalculateTileSize(
     const gfx::Size& content_bounds) const {
   if (is_mask_) {
     int max_size = layer_tree_impl()->MaxTextureSize();
     return gfx::Size(
         std::min(max_size, content_bounds.width()),
         std::min(max_size, content_bounds.height()));
   }
 
   int max_texture_size =
@@ skipping 190 matching lines @@
       continue;
     }
     for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                    contents_scale_x(),
                                                    rect);
          iter;
          ++iter) {
       if (!*iter || !iter->IsReadyToDraw())
         continue;
 
-      // This iteration is over the visible content rect which is potentially
-      // less conservative than projecting the viewport into the layer.
-      // Ignore tiles that are know to be outside the viewport.
-      if (iter->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
-        continue;
-
       missing_region.Subtract(iter.geometry_rect());
       iter->MarkRequiredForActivation();
     }
   }
   DCHECK(high_res) << "There must be one high res tiling";
 
   // If these pointers are null (because no twin, no matching tiling, or the
   // simpification just below), then high res tiles will be required to fill any
   // holes left by the first pass above.  If the pointers are valid, then this
   // layer is allowed to skip any tiles that are not ready on its twin.
@@ skipping 48 matching lines @@
   for (PictureLayerTiling::CoverageIterator iter(tiling,
                                                  contents_scale,
                                                  rect);
        iter;
        ++iter) {
     Tile* tile = *iter;
     // A null tile (i.e. missing recording) can just be skipped.
     if (!tile)
       continue;
 
-    // This iteration is over the visible content rect which is potentially
-    // less conservative than projecting the viewport into the layer.
-    // Ignore tiles that are know to be outside the viewport.
-    if (tile->priority(PENDING_TREE).distance_to_visible_in_pixels != 0)
-      continue;
-
     // If the missing region doesn't cover it, this tile is fully
     // covered by acceptable tiles at other scales.
     if (!missing_region.Intersects(iter.geometry_rect()))
       continue;
 
     // If the twin tile doesn't exist (i.e. missing recording or so far away
     // that it is outside the visible tile rect) or this tile is shared between
     // with the twin, then this tile isn't required to prevent flashing.
     if (optional_twin_tiling) {
       Tile* twin_tile = optional_twin_tiling->TileAt(iter.i(), iter.j());
@@ skipping 420 matching lines @@
 size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
   const_cast<PictureLayerImpl*>(this)->DoPostCommitInitializationIfNeeded();
   return tilings_->GPUMemoryUsageInBytes();
 }
 
 void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc