From 85bb1b9306f145749c5c6aa4e527a95972111001 Mon Sep 17 00:00:00 2001 From: vmpstr Date: Tue, 18 Nov 2014 10:26:58 -0800 Subject: [PATCH] cc: Move more direct tilings accesses to from PLI to PLTS. This patch moves more tilings iterations from the layer to the tiling set behind an interface. R=danakj, enne BUG=433048 Review URL: https://codereview.chromium.org/733123003 Cr-Commit-Position: refs/heads/master@{#304643} --- cc/layers/picture_layer_impl.cc | 108 +++++++++++-------------------- cc/layers/picture_layer_impl.h | 1 - cc/resources/picture_layer_tiling_set.cc | 58 +++++++++++++++++ cc/resources/picture_layer_tiling_set.h | 18 ++++++ 4 files changed, 114 insertions(+), 71 deletions(-) diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc index 111a0e718312..a3cdfa3fefd1 100644 --- a/cc/layers/picture_layer_impl.cc +++ b/cc/layers/picture_layer_impl.cc @@ -889,13 +889,7 @@ void PictureLayerImpl::RemoveTiling(float contents_scale) { if (!tilings_ || tilings_->num_tilings() == 0) return; - for (size_t i = 0; i < tilings_->num_tilings(); ++i) { - PictureLayerTiling* tiling = tilings_->tiling_at(i); - if (tiling->contents_scale() == contents_scale) { - tilings_->Remove(tiling); - break; - } - } + tilings_->RemoveTilingWithScale(contents_scale); if (tilings_->num_tilings() == 0) ResetRasterScale(); SanityCheckTilingState(); @@ -908,20 +902,11 @@ void PictureLayerImpl::RemoveAllTilings() { ResetRasterScale(); } -namespace { - -inline float PositiveRatio(float float1, float float2) { - DCHECK_GT(float1, 0); - DCHECK_GT(float2, 0); - return float1 > float2 ? float1 / float2 : float2 / float1; -} - -} // namespace - void PictureLayerImpl::AddTilingsForRasterScale() { PictureLayerTiling* high_res = nullptr; PictureLayerTiling* low_res = nullptr; + // TODO(vmpstr): Put this logic into PictureLayerTilingSet. for (size_t i = 0; i < tilings_->num_tilings(); ++i) { PictureLayerTiling* tiling = tilings_->tiling_at(i); if (tiling->contents_scale() == raster_contents_scale_) @@ -999,21 +984,6 @@ bool PictureLayerImpl::ShouldAdjustRasterScale() const { return false; } -float PictureLayerImpl::SnappedContentsScale(float scale) { - // If a tiling exists within the max snapping ratio, snap to its scale. - float snapped_contents_scale = scale; - float snapped_ratio = kSnapToExistingTilingRatio; - for (size_t i = 0; i < tilings_->num_tilings(); ++i) { - float tiling_contents_scale = tilings_->tiling_at(i)->contents_scale(); - float ratio = PositiveRatio(tiling_contents_scale, scale); - if (ratio < snapped_ratio) { - snapped_contents_scale = tiling_contents_scale; - snapped_ratio = ratio; - } - } - return snapped_contents_scale; -} - void PictureLayerImpl::RecalculateRasterScales() { float old_raster_contents_scale = raster_contents_scale_; float old_raster_page_scale = raster_page_scale_; @@ -1058,7 +1028,8 @@ void PictureLayerImpl::RecalculateRasterScales() { while (desired_contents_scale < ideal_contents_scale_) desired_contents_scale *= kMaxScaleRatioDuringPinch; } - raster_contents_scale_ = SnappedContentsScale(desired_contents_scale); + raster_contents_scale_ = tilings_->GetSnappedContentsScale( + desired_contents_scale, kSnapToExistingTilingRatio); raster_page_scale_ = raster_contents_scale_ / raster_device_scale_ / raster_source_scale_; } @@ -1142,14 +1113,14 @@ void PictureLayerImpl::CleanUpTilingsOnActiveLayer( // TODO(danakj): Remove the tilings_ check when we create them in the // constructor. if (twin->tilings_) { - for (size_t i = 0; i < twin->tilings_->num_tilings(); ++i) { - PictureLayerTiling* tiling = twin->tilings_->tiling_at(i); - if (tiling->resolution() == LOW_RESOLUTION) - twin_low_res_scale = tiling->contents_scale(); - } + PictureLayerTiling* tiling = + twin->tilings_->FindTilingWithResolution(LOW_RESOLUTION); + if (tiling) + twin_low_res_scale = tiling->contents_scale(); } } + // TODO(vmpstr): Put this logic into PictureLayerTilingSet. std::vector to_remove; for (size_t i = 0; i < tilings_->num_tilings(); ++i) { PictureLayerTiling* tiling = tilings_->tiling_at(i); @@ -1269,12 +1240,8 @@ bool PictureLayerImpl::ShouldAdjustRasterScaleDuringScaleAnimations() const { } float PictureLayerImpl::MaximumTilingContentsScale() const { - float max_contents_scale = MinimumContentsScale(); - for (size_t i = 0; i < tilings_->num_tilings(); ++i) { - const PictureLayerTiling* tiling = tilings_->tiling_at(i); - max_contents_scale = std::max(max_contents_scale, tiling->contents_scale()); - } - return max_contents_scale; + float max_contents_scale = tilings_->GetMaximumContentsScale(); + return std::max(max_contents_scale, MinimumContentsScale()); } void PictureLayerImpl::UpdateIdealScales() { @@ -1310,9 +1277,7 @@ void PictureLayerImpl::GetAllTilesForTracing( std::set* tiles) const { if (!tilings_) return; - - for (size_t i = 0; i < tilings_->num_tilings(); ++i) - tilings_->tiling_at(i)->GetAllTilesForTracing(tiles); + tilings_->GetAllTilesForTracing(tiles); } void PictureLayerImpl::AsValueInto(base::debug::TracedValue* state) const { @@ -1394,31 +1359,34 @@ bool PictureLayerImpl::AllTilesRequiredAreReadyToDraw( gfx::Rect rect = GetViewportForTilePriorityInContentSpace(); rect.Intersect(visible_rect_for_tile_priority_); - for (size_t i = 0; i < tilings_->num_tilings(); ++i) { - PictureLayerTiling* tiling = tilings_->tiling_at(i); - if (tiling->resolution() != HIGH_RESOLUTION && - tiling->resolution() != LOW_RESOLUTION) - continue; + // 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); + if (!tiling) + return true; - for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter; - ++iter) { - const Tile* tile = *iter; - // 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; + for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter; + ++iter) { + const Tile* tile = *iter; + // 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->*is_tile_required_callback)(tile) && - !tile->IsReadyToDraw()) { - TRACE_EVENT_INSTANT0("cc", "Tile required, but not ready to draw.", - TRACE_EVENT_SCOPE_THREAD); - return false; - } + // 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->*is_tile_required_callback)(tile) && !tile->IsReadyToDraw()) { + TRACE_EVENT_INSTANT0("cc", "Tile required, but not ready to draw.", + TRACE_EVENT_SCOPE_THREAD); + return false; } } diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h index 78b13fcc1c96..12209a8472d1 100644 --- a/cc/layers/picture_layer_impl.h +++ b/cc/layers/picture_layer_impl.h @@ -168,7 +168,6 @@ class CC_EXPORT PictureLayerImpl void CleanUpTilingsOnActiveLayer( std::vector used_tilings); float MinimumContentsScale() const; - float SnappedContentsScale(float new_contents_scale); void ResetRasterScale(); gfx::Rect GetViewportForTilePriorityInContentSpace() const; PictureLayerImpl* GetRecycledTwinLayer() const; diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc index 060bd27faf08..7c20e2225b34 100644 --- a/cc/resources/picture_layer_tiling_set.cc +++ b/cc/resources/picture_layer_tiling_set.cc @@ -5,6 +5,7 @@ #include "cc/resources/picture_layer_tiling_set.h" #include +#include namespace cc { @@ -17,6 +18,12 @@ class LargestToSmallestScaleFunctor { } }; +inline float LargerRatio(float float1, float float2) { + DCHECK_GT(float1, 0.f); + DCHECK_GT(float2, 0.f); + return float1 > float2 ? float1 / float2 : float2 / float1; +} + } // namespace // static @@ -135,6 +142,17 @@ PictureLayerTiling* PictureLayerTilingSet::TilingAtScale(float scale) const { return NULL; } +PictureLayerTiling* PictureLayerTilingSet::FindTilingWithResolution( + TileResolution resolution) const { + auto iter = std::find_if(tilings_.begin(), tilings_.end(), + [resolution](const PictureLayerTiling* tiling) { + return tiling->resolution() == resolution; + }); + if (iter == tilings_.end()) + return NULL; + return *iter; +} + void PictureLayerTilingSet::RemoveAllTilings() { tilings_.clear(); } @@ -147,11 +165,45 @@ void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) { tilings_.erase(iter); } +void PictureLayerTilingSet::RemoveTilingWithScale(float scale) { + auto iter = std::find_if(tilings_.begin(), tilings_.end(), + [scale](const PictureLayerTiling* tiling) { + return tiling->contents_scale() == scale; + }); + if (iter == tilings_.end()) + return; + tilings_.erase(iter); +} + void PictureLayerTilingSet::RemoveAllTiles() { for (size_t i = 0; i < tilings_.size(); ++i) tilings_[i]->Reset(); } +float PictureLayerTilingSet::GetSnappedContentsScale( + 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(); + 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 tilings_[0]->contents_scale(); +} + bool PictureLayerTilingSet::UpdateTilePriorities( const gfx::Rect& required_rect_in_layer_space, float ideal_contents_scale, @@ -181,6 +233,12 @@ bool PictureLayerTilingSet::UpdateTilePriorities( return true; } +void PictureLayerTilingSet::GetAllTilesForTracing( + std::set* tiles) const { + for (auto* tiling : tilings_) + tiling->GetAllTilesForTracing(tiles); +} + PictureLayerTilingSet::CoverageIterator::CoverageIterator( const PictureLayerTilingSet* set, float contents_scale, diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h index 489bc0c37b07..08946bf8f3e2 100644 --- a/cc/resources/picture_layer_tiling_set.h +++ b/cc/resources/picture_layer_tiling_set.h @@ -5,6 +5,8 @@ #ifndef CC_RESOURCES_PICTURE_LAYER_TILING_SET_H_ #define CC_RESOURCES_PICTURE_LAYER_TILING_SET_H_ +#include + #include "cc/base/region.h" #include "cc/base/scoped_ptr_vector.h" #include "cc/resources/picture_layer_tiling.h" @@ -64,13 +66,27 @@ class CC_EXPORT PictureLayerTilingSet { return tilings_[idx]; } + // TODO(vmpstr): Rename to FindTilingWithScale. PictureLayerTiling* TilingAtScale(float scale) const; + PictureLayerTiling* FindTilingWithResolution(TileResolution resolution) const; + + // If a tiling exists whose scale is within |snap_to_existing_tiling_ratio| + // ratio of |start_scale|, then return that tiling's scale. Otherwise, return + // |start_scale|. If multiple tilings match the criteria, return the one with + // the least ratio to |start_scale|. + float GetSnappedContentsScale(float start_scale, + float snap_to_existing_tiling_ratio) const; + + // Returns the maximum contents scale of all tilings, or 0 if no tilings + // exist. + float GetMaximumContentsScale() const; // Remove all tilings. void RemoveAllTilings(); // Remove one tiling. void Remove(PictureLayerTiling* tiling); + void RemoveTilingWithScale(float scale); // Remove all tiles; keep all tilings. void RemoveAllTiles(); @@ -82,6 +98,8 @@ class CC_EXPORT PictureLayerTilingSet { const Occlusion& occlusion_in_layer_space, bool can_require_tiles_for_activation); + void GetAllTilesForTracing(std::set* tiles) const; + // For a given rect, iterates through tiles that can fill it. If no // set of tiles with resources can fill the rect, then it will iterate // through null tiles with valid geometry_rect() until the rect is full. -- 2.11.4.GIT