cc: Remove separate x/y raster scales.

cc/tiles/picture_layer_tiling_set.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/tiles/picture_layer_tiling_set.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <set>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/playback/raster_source.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace {
 
 class LargestToSmallestScaleFunctor {
  public:
   bool operator()(const std::unique_ptr<PictureLayerTiling>& left,
                   const std::unique_ptr<PictureLayerTiling>& right) {
-    return left->contents_scale_key() > right->contents_scale_key();
+    return left->contents_scale() > right->contents_scale();
   }
 };
 
 inline float LargerRatio(float float1, float float2) {
   DCHECK_GT(float1, 0.f);
   DCHECK_GT(float2, 0.f);
   return float1 > float2 ? float1 / float2 : float2 / float1;
 }
 
 const float kSoonBorderDistanceViewportPercentage = 0.15f;
@@ skipping 40 matching lines @@
     // If the twin (pending) tiling set is empty, it was not updated for the
     // current frame. So we drop tilings from our set as well, instead of
     // leaving behind unshared tilings that are all non-ideal.
     RemoveAllTilings();
     return;
   }
 
   bool tiling_sort_required = false;
   for (const auto& pending_twin_tiling : pending_twin_set->tilings_) {
     PictureLayerTiling* this_tiling =
-        FindTilingWithScaleKey(pending_twin_tiling->contents_scale_key());
+        FindTilingWithScaleKey(pending_twin_tiling->contents_scale());
     if (!this_tiling) {
       std::unique_ptr<PictureLayerTiling> new_tiling(new PictureLayerTiling(
-          tree_, pending_twin_tiling->raster_scales(), raster_source_, client_,
+          tree_, pending_twin_tiling->contents_scale(), raster_source_, client_,
           kMaxSoonBorderDistanceInScreenPixels, max_preraster_distance_));
       tilings_.push_back(std::move(new_tiling));
       this_tiling = tilings_.back().get();
       tiling_sort_required = true;
       state_since_last_tile_priority_update_.added_tilings = true;
     }
     this_tiling->TakeTilesAndPropertiesFrom(pending_twin_tiling.get(),
                                             layer_invalidation);
   }
 
   if (tiling_sort_required) {
     std::sort(tilings_.begin(), tilings_.end(),
               LargestToSmallestScaleFunctor());
   }
 }
 
 void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForActivation(
     scoped_refptr<RasterSource> raster_source,
     const PictureLayerTilingSet* pending_twin_set,
     const Region& layer_invalidation,
-    float minimum_contents_scale_key,
-    float maximum_contents_scale_key) {
-  RemoveTilingsBelowScaleKey(minimum_contents_scale_key);
-  RemoveTilingsAboveScaleKey(maximum_contents_scale_key);
+    float minimum_contents_scale,
+    float maximum_contents_scale) {
+  RemoveTilingsBelowScaleKey(minimum_contents_scale);
+  RemoveTilingsAboveScaleKey(maximum_contents_scale);
 
   raster_source_ = raster_source;
 
   // Copy over tilings that are shared with the |pending_twin_set| tiling set.
   // Also, copy all of the properties from twin tilings.
   CopyTilingsAndPropertiesFromPendingTwin(pending_twin_set, raster_source,
                                           layer_invalidation);
 
   // If the tiling is not shared (FindTilingWithScale returns nullptr), then
   // invalidate tiles and update them to the new raster source.
   for (const auto& tiling : tilings_) {
-    if (pending_twin_set->FindTilingWithScaleKey(tiling->contents_scale_key()))
+    if (pending_twin_set->FindTilingWithScaleKey(tiling->contents_scale()))
       continue;
 
     tiling->SetRasterSourceAndResize(raster_source);
     tiling->Invalidate(layer_invalidation);
     state_since_last_tile_priority_update_.invalidated = true;
     // This is needed for cases where the live tiles rect didn't change but
     // recordings exist in the raster source that did not exist on the last
     // raster source.
     tiling->CreateMissingTilesInLiveTilesRect();
 
     // |this| is active set and |tiling| is not in the pending set, which means
     // it is now NON_IDEAL_RESOLUTION. The exception is for LOW_RESOLUTION
     // tilings, which are computed and created entirely on the active tree.
     // Since the pending tree does not have them, we should just leave them as
     // low resolution to not lose them.
     if (tiling->resolution() != LOW_RESOLUTION)
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
   }
 
   VerifyTilings(pending_twin_set);
 }
 
 void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForCommit(
     scoped_refptr<RasterSource> raster_source,
     const Region& layer_invalidation,
-    float minimum_contents_scale_key,
-    float maximum_contents_scale_key) {
-  RemoveTilingsBelowScaleKey(minimum_contents_scale_key);
-  RemoveTilingsAboveScaleKey(maximum_contents_scale_key);
+    float minimum_contents_scale,
+    float maximum_contents_scale) {
+  RemoveTilingsBelowScaleKey(minimum_contents_scale);
+  RemoveTilingsAboveScaleKey(maximum_contents_scale);
 
   raster_source_ = raster_source;
 
   // Invalidate tiles and update them to the new raster source.
   for (const std::unique_ptr<PictureLayerTiling>& tiling : tilings_) {
     DCHECK(tree_ != PENDING_TREE || !tiling->has_tiles());
     tiling->SetRasterSourceAndResize(raster_source);
 
     // Force |UpdateTilePriorities| on commit for cases where the compositor is
     // heavily pipelined resulting in back to back draw and commit. This
@@ skipping 58 matching lines @@
 }
 
 void PictureLayerTilingSet::CleanUpTilings(
     float min_acceptable_high_res_scale_key,
     float max_acceptable_high_res_scale_key,
     const std::vector<PictureLayerTiling*>& needed_tilings,
     PictureLayerTilingSet* twin_set) {
   std::vector<PictureLayerTiling*> to_remove;
   for (const auto& tiling : tilings_) {
     // Keep all tilings within the min/max scales.
-    if (tiling->contents_scale_key() >= min_acceptable_high_res_scale_key &&
-        tiling->contents_scale_key() <= max_acceptable_high_res_scale_key) {
+    if (tiling->contents_scale() >= min_acceptable_high_res_scale_key &&
+        tiling->contents_scale() <= max_acceptable_high_res_scale_key) {
       continue;
     }
 
     // Keep low resolution tilings.
     if (tiling->resolution() == LOW_RESOLUTION)
       continue;
 
     // Don't remove tilings that are required.
     if (std::find(needed_tilings.begin(), needed_tilings.end(), tiling.get()) !=
         needed_tilings.end()) {
@@ skipping 17 matching lines @@
                      });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
   for (const auto& tiling : tilings_)
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
 }
 
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(
-    float contents_scale_key,
+    float contents_scale,
     scoped_refptr<RasterSource> raster_source) {
   if (!raster_source_)
     raster_source_ = raster_source;
 
 #if DCHECK_IS_ON()
   for (size_t i = 0; i < tilings_.size(); ++i) {
-    DCHECK_NE(tilings_[i]->contents_scale_key(), contents_scale_key);
+    DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
     DCHECK_EQ(tilings_[i]->raster_source(), raster_source.get());
   }
 #endif  // DCHECK_IS_ON()
 
-  gfx::SizeF raster_scales(contents_scale_key,
-                           contents_scale_key / aspect_ratio_);
   tilings_.push_back(base::MakeUnique<PictureLayerTiling>(
-      tree_, raster_scales, raster_source, client_,
+      tree_, contents_scale, raster_source, client_,
       kMaxSoonBorderDistanceInScreenPixels, max_preraster_distance_));
   PictureLayerTiling* appended = tilings_.back().get();
   state_since_last_tile_priority_update_.added_tilings = true;
 
   std::sort(tilings_.begin(), tilings_.end(), LargestToSmallestScaleFunctor());
   return appended;
 }
 
 int PictureLayerTilingSet::NumHighResTilings() const {
   return std::count_if(tilings_.begin(), tilings_.end(),
                        [](const std::unique_ptr<PictureLayerTiling>& tiling) {
                          return tiling->resolution() == HIGH_RESOLUTION;
                        });
 }
 
 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithScaleKey(
     float scale_key) const {
   for (size_t i = 0; i < tilings_.size(); ++i) {
-    if (tilings_[i]->contents_scale_key() == scale_key)
+    if (tilings_[i]->contents_scale() == scale_key)
       return tilings_[i].get();
   }
   return nullptr;
 }
 
 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithResolution(
     TileResolution resolution) const {
   auto iter = std::find_if(
       tilings_.begin(), tilings_.end(),
       [resolution](const std::unique_ptr<PictureLayerTiling>& tiling) {
         return tiling->resolution() == resolution;
       });
   if (iter == tilings_.end())
     return nullptr;
   return iter->get();
 }
 
 void PictureLayerTilingSet::RemoveTilingsBelowScaleKey(
     float minimum_scale_key) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
       [minimum_scale_key](const std::unique_ptr<PictureLayerTiling>& tiling) {
-        return tiling->contents_scale_key() < minimum_scale_key;
+        return tiling->contents_scale() < minimum_scale_key;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::RemoveTilingsAboveScaleKey(
     float maximum_scale_key) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
       [maximum_scale_key](const std::unique_ptr<PictureLayerTiling>& tiling) {
-        return tiling->contents_scale_key() > maximum_scale_key;
+        return tiling->contents_scale() > maximum_scale_key;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
 
 void PictureLayerTilingSet::RemoveAllTilings() {
   tilings_.clear();
 }
 
 void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
   auto iter = std::find_if(
@@ skipping 11 matching lines @@
     tilings_[i]->Reset();
 }
 
 float PictureLayerTilingSet::GetSnappedContentsScaleKey(
     float start_scale,
     float snap_to_existing_tiling_ratio) const {
   // If a tiling exists within the max snapping ratio, snap to its scale.
   float snapped_contents_scale = start_scale;
   float snapped_ratio = snap_to_existing_tiling_ratio;
   for (const auto& tiling : tilings_) {
-    float tiling_contents_scale = tiling->contents_scale_key();
+    float tiling_contents_scale = tiling->contents_scale();
     float ratio = LargerRatio(tiling_contents_scale, start_scale);
     if (ratio < snapped_ratio) {
       snapped_contents_scale = tiling_contents_scale;
       snapped_ratio = ratio;
     }
   }
   return snapped_contents_scale;
 }
 
 float PictureLayerTilingSet::GetMaximumContentsScale() const {
   if (tilings_.empty())
     return 0.f;
   // The first tiling has the largest contents scale.
-  return std::max(tilings_[0]->raster_scales().width(),
-                  tilings_[0]->raster_scales().height());
+  return tilings_[0]->contents_scale();
 }
 
 bool PictureLayerTilingSet::TilingsNeedUpdate(
     const gfx::Rect& visible_rect_in_layer_space,
     double current_frame_time_in_seconds) {
   // If we don't have any tilings, we don't need an update.
   if (num_tilings() == 0)
     return false;
 
   // If we never updated the tiling set, then our history is empty. We should
@@ skipping 146 matching lines @@
     tiling->set_can_require_tiles_for_activation(
         can_require_tiles_for_activation);
     tiling->ComputeTilePriorityRects(
         visible_rect_in_layer_space_, skewport_in_layer_space_,
         soon_border_rect_in_layer_space_, eventually_rect_in_layer_space_,
         ideal_contents_scale, occlusion_in_layer_space);
   }
   return true;
 }
 
-void PictureLayerTilingSet::SetAspectRatio(float ratio) {
-  if (std::abs(ratio - aspect_ratio_) < std::numeric_limits<float>::epsilon())
-    return;
-  TRACE_EVENT1("cc", "PictureLayerTilingSet::SetAspectRatio", "aspect_ratio",
-               ratio);
-  aspect_ratio_ = ratio;
-  RemoveAllTilings();
-}
-
 void PictureLayerTilingSet::GetAllPrioritizedTilesForTracing(
     std::vector<PrioritizedTile>* prioritized_tiles) const {
   for (const auto& tiling : tilings_)
     tiling->GetAllPrioritizedTilesForTracing(prioritized_tiles);
 }
 
 PictureLayerTilingSet::CoverageIterator::CoverageIterator(
     const PictureLayerTilingSet* set,
     float coverage_scale,
     const gfx::Rect& coverage_rect,
     float ideal_contents_scale)
     : set_(set),
       coverage_scale_(coverage_scale),
       current_tiling_(std::numeric_limits<size_t>::max()) {
   missing_region_.Union(coverage_rect);
 
   // Determine the smallest content_scale tiling which a scale higher than the
   // ideal (or the first tiling if all tilings have a scale less than ideal).
   size_t tilings_size = set_->tilings_.size();
   for (ideal_tiling_ = 0; ideal_tiling_ < tilings_size; ++ideal_tiling_) {
     PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_].get();
-    if (tiling->contents_scale_key() < ideal_contents_scale) {
+    if (tiling->contents_scale() < ideal_contents_scale) {
       if (ideal_tiling_ > 0)
         ideal_tiling_--;
       break;
     }
   }
 
   // If all tilings have a scale larger than the ideal, then use the smallest
   // scale (which is the last one).
   if (ideal_tiling_ == tilings_size && ideal_tiling_ > 0)
     ideal_tiling_--;
@@ skipping 188 matching lines @@
     case LOWER_THAN_LOW_RES:
       range = TilingRange(low_res_range.end, tilings_size);
       break;
   }
 
   DCHECK_LE(range.start, range.end);
   return range;
 }
 
 }  // namespace cc