// 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 #include #include "base/time/time.h" #include "cc/base/math_util.h" #include "cc/base/util.h" #include "cc/debug/debug_colors.h" #include "cc/debug/micro_benchmark_impl.h" #include "cc/debug/traced_value.h" #include "cc/layers/append_quads_data.h" #include "cc/layers/quad_sink.h" #include "cc/quads/checkerboard_draw_quad.h" #include "cc/quads/debug_border_draw_quad.h" #include "cc/quads/picture_draw_quad.h" #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 "ui/gfx/quad_f.h" #include "ui/gfx/rect_conversions.h" #include "ui/gfx/size_conversions.h" namespace { 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 = 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), raster_source_scale_was_animating_(false), is_using_lcd_text_(tree_impl->settings().can_use_lcd_text), needs_post_commit_initialization_(true), should_update_tile_priorities_(false), should_use_gpu_rasterization_(tree_impl->settings().gpu_rasterization) {} PictureLayerImpl::~PictureLayerImpl() {} const char* PictureLayerImpl::LayerTypeAsString() const { return "cc::PictureLayerImpl"; } scoped_ptr PictureLayerImpl::CreateLayerImpl( LayerTreeImpl* tree_impl) { return PictureLayerImpl::Create(tree_impl, id()).PassAs(); } void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) { // It's possible this layer was never drawn or updated (e.g. because it was // a descendant of an opacity 0 layer). DoPostCommitInitializationIfNeeded(); PictureLayerImpl* layer_impl = static_cast(base_layer); // We have already synced the important bits from the the active layer, and // we will soon swap out its tilings and use them for recycling. However, // there are now tiles in this layer's tilings that were unref'd and replaced // with new tiles (due to invalidation). This resets all active priorities on // the to-be-recycled tiling to ensure replaced tiles don't linger and take // memory (due to a stale 'active' priority). if (layer_impl->tilings_) layer_impl->tilings_->DidBecomeRecycled(); LayerImpl::PushPropertiesTo(base_layer); // When the pending tree pushes to the active tree, the pending twin // disappears. layer_impl->twin_layer_ = NULL; twin_layer_ = NULL; layer_impl->SetIsMask(is_mask_); layer_impl->pile_ = pile_; // Tilings would be expensive to push, so we swap. This optimization requires // an extra invalidation in SyncFromActiveLayer. layer_impl->tilings_.swap(tilings_); layer_impl->tilings_->SetClient(layer_impl); if (tilings_) tilings_->SetClient(this); layer_impl->raster_page_scale_ = raster_page_scale_; layer_impl->raster_device_scale_ = raster_device_scale_; layer_impl->raster_source_scale_ = raster_source_scale_; layer_impl->raster_contents_scale_ = raster_contents_scale_; layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_; layer_impl->UpdateLCDTextStatus(is_using_lcd_text_); layer_impl->needs_post_commit_initialization_ = false; // The invalidation on this soon-to-be-recycled layer must be cleared to // mirror clearing the invalidation in PictureLayer's version of this function // in case push properties is skipped. layer_impl->invalidation_.Swap(&invalidation_); invalidation_.Clear(); needs_post_commit_initialization_ = true; // We always need to push properties. // See http://crbug.com/303943 needs_push_properties_ = true; } void PictureLayerImpl::AppendQuads(QuadSink* quad_sink, AppendQuadsData* append_quads_data) { DCHECK(!needs_post_commit_initialization_); gfx::Rect rect(visible_content_rect()); gfx::Rect content_rect(content_bounds()); SharedQuadState* shared_quad_state = quad_sink->UseSharedQuadState(CreateSharedQuadState()); if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) { AppendDebugBorderQuad( quad_sink, shared_quad_state, append_quads_data, DebugColors::DirectPictureBorderColor(), DebugColors::DirectPictureBorderWidth(layer_tree_impl())); gfx::Rect geometry_rect = rect; gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect(); gfx::Size texture_size = rect.size(); gfx::RectF texture_rect = gfx::RectF(texture_size); gfx::Rect quad_content_rect = rect; float contents_scale = contents_scale_x(); scoped_ptr quad = PictureDrawQuad::Create(); quad->SetNew(shared_quad_state, geometry_rect, opaque_rect, texture_rect, texture_size, RGBA_8888, quad_content_rect, contents_scale, pile_); if (quad_sink->Append(quad.PassAs(), append_quads_data)) append_quads_data->num_missing_tiles++; return; } AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data); if (ShowDebugBorders()) { for (PictureLayerTilingSet::CoverageIterator iter( tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_); iter; ++iter) { SkColor color; float width; if (*iter && iter->IsReadyToDraw()) { ManagedTileState::TileVersion::Mode mode = iter->GetTileVersionForDrawing().mode(); if (mode == ManagedTileState::TileVersion::SOLID_COLOR_MODE) { color = DebugColors::SolidColorTileBorderColor(); width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl()); } else if (mode == ManagedTileState::TileVersion::PICTURE_PILE_MODE) { color = DebugColors::PictureTileBorderColor(); width = DebugColors::PictureTileBorderWidth(layer_tree_impl()); } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) { color = DebugColors::HighResTileBorderColor(); width = DebugColors::HighResTileBorderWidth(layer_tree_impl()); } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) { color = DebugColors::LowResTileBorderColor(); width = DebugColors::LowResTileBorderWidth(layer_tree_impl()); } else if (iter->contents_scale() > contents_scale_x()) { color = DebugColors::ExtraHighResTileBorderColor(); width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl()); } else { color = DebugColors::ExtraLowResTileBorderColor(); width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl()); } } else { color = DebugColors::MissingTileBorderColor(); width = DebugColors::MissingTileBorderWidth(layer_tree_impl()); } scoped_ptr debug_border_quad = DebugBorderDrawQuad::Create(); gfx::Rect geometry_rect = iter.geometry_rect(); debug_border_quad->SetNew(shared_quad_state, geometry_rect, color, width); quad_sink->Append(debug_border_quad.PassAs(), append_quads_data); } } // Keep track of the tilings that were used so that tilings that are // unused can be considered for removal. std::vector seen_tilings; for (PictureLayerTilingSet::CoverageIterator iter( tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_); iter; ++iter) { gfx::Rect geometry_rect = iter.geometry_rect(); if (!*iter || !iter->IsReadyToDraw()) { if (DrawCheckerboardForMissingTiles()) { // TODO(enne): Figure out how to show debug "invalidated checker" color scoped_ptr quad = CheckerboardDrawQuad::Create(); SkColor color = DebugColors::DefaultCheckerboardColor(); quad->SetNew(shared_quad_state, geometry_rect, color); if (quad_sink->Append(quad.PassAs(), append_quads_data)) append_quads_data->num_missing_tiles++; } else { SkColor color = SafeOpaqueBackgroundColor(); scoped_ptr quad = SolidColorDrawQuad::Create(); quad->SetNew(shared_quad_state, geometry_rect, color, false); if (quad_sink->Append(quad.PassAs(), append_quads_data)) append_quads_data->num_missing_tiles++; } append_quads_data->had_incomplete_tile = true; continue; } const ManagedTileState::TileVersion& tile_version = iter->GetTileVersionForDrawing(); scoped_ptr draw_quad; switch (tile_version.mode()) { case ManagedTileState::TileVersion::RESOURCE_MODE: { gfx::RectF texture_rect = iter.texture_rect(); gfx::Rect opaque_rect = iter->opaque_rect(); opaque_rect.Intersect(geometry_rect); if (iter->contents_scale() != ideal_contents_scale_) append_quads_data->had_incomplete_tile = true; scoped_ptr quad = TileDrawQuad::Create(); quad->SetNew(shared_quad_state, geometry_rect, opaque_rect, tile_version.get_resource_id(), texture_rect, iter.texture_size(), tile_version.contents_swizzled()); draw_quad = quad.PassAs(); break; } case ManagedTileState::TileVersion::PICTURE_PILE_MODE: { gfx::RectF texture_rect = iter.texture_rect(); gfx::Rect opaque_rect = iter->opaque_rect(); opaque_rect.Intersect(geometry_rect); ResourceProvider* resource_provider = layer_tree_impl()->resource_provider(); ResourceFormat format = resource_provider->memory_efficient_texture_format(); scoped_ptr quad = PictureDrawQuad::Create(); quad->SetNew(shared_quad_state, geometry_rect, opaque_rect, texture_rect, iter.texture_size(), format, iter->content_rect(), iter->contents_scale(), pile_); draw_quad = quad.PassAs(); break; } case ManagedTileState::TileVersion::SOLID_COLOR_MODE: { scoped_ptr quad = SolidColorDrawQuad::Create(); quad->SetNew(shared_quad_state, geometry_rect, tile_version.get_solid_color(), false); draw_quad = quad.PassAs(); break; } } DCHECK(draw_quad); quad_sink->Append(draw_quad.Pass(), append_quads_data); if (seen_tilings.empty() || seen_tilings.back() != iter.CurrentTiling()) seen_tilings.push_back(iter.CurrentTiling()); } // Aggressively remove any tilings that are not seen to save memory. Note // that this is at the expense of doing cause more frequent re-painting. A // better scheme would be to maintain a tighter visible_content_rect for the // finer tilings. CleanUpTilingsOnActiveLayer(seen_tilings); } void PictureLayerImpl::UpdateTilePriorities() { DCHECK(!needs_post_commit_initialization_); CHECK(should_update_tile_priorities_); if (!layer_tree_impl()->device_viewport_valid_for_tile_management()) { for (size_t i = 0; i < tilings_->num_tilings(); ++i) DCHECK(tilings_->tiling_at(i)->has_ever_been_updated()); return; } if (!tilings_->num_tilings()) return; double current_frame_time_in_seconds = (layer_tree_impl()->CurrentFrameTimeTicks() - base::TimeTicks()).InSecondsF(); bool tiling_needs_update = false; for (size_t i = 0; i < tilings_->num_tilings(); ++i) { if (tilings_->tiling_at(i)->NeedsUpdateForFrameAtTime( 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)); } 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); 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(); } void PictureLayerImpl::DidBeginTracing() { pile_->DidBeginTracing(); } void PictureLayerImpl::ReleaseResources() { if (tilings_) RemoveAllTilings(); ResetRasterScale(); } void PictureLayerImpl::CalculateContentsScale( float ideal_contents_scale, float device_scale_factor, float page_scale_factor, bool animating_transform_to_screen, float* contents_scale_x, float* contents_scale_y, gfx::Size* content_bounds) { DoPostCommitInitializationIfNeeded(); // This function sets valid raster scales and manages tilings, so tile // priorities can now be updated. should_update_tile_priorities_ = true; if (!CanHaveTilings()) { ideal_page_scale_ = page_scale_factor; ideal_device_scale_ = device_scale_factor; ideal_contents_scale_ = ideal_contents_scale; ideal_source_scale_ = ideal_contents_scale_ / ideal_page_scale_ / ideal_device_scale_; *contents_scale_x = ideal_contents_scale_; *contents_scale_y = ideal_contents_scale_; *content_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), ideal_contents_scale_, ideal_contents_scale_)); return; } float min_contents_scale = MinimumContentsScale(); DCHECK_GT(min_contents_scale, 0.f); float min_page_scale = layer_tree_impl()->min_page_scale_factor(); DCHECK_GT(min_page_scale, 0.f); float min_device_scale = 1.f; float min_source_scale = min_contents_scale / min_page_scale / min_device_scale; float ideal_page_scale = page_scale_factor; float ideal_device_scale = device_scale_factor; float ideal_source_scale = ideal_contents_scale / ideal_page_scale / ideal_device_scale; ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale); ideal_page_scale_ = ideal_page_scale; ideal_device_scale_ = ideal_device_scale; ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale); ManageTilings(animating_transform_to_screen); // The content scale and bounds for a PictureLayerImpl is somewhat fictitious. // There are (usually) several tilings at different scales. However, the // content bounds is the (integer!) space in which quads are generated. // In order to guarantee that we can fill this integer space with any set of // tilings (and then map back to floating point texture coordinates), the // contents scale must be at least as large as the largest of the tilings. float max_contents_scale = min_contents_scale; 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()); } *contents_scale_x = max_contents_scale; *contents_scale_y = max_contents_scale; *content_bounds = gfx::ToCeiledSize( gfx::ScaleSize(bounds(), max_contents_scale, max_contents_scale)); } skia::RefPtr PictureLayerImpl::GetPicture() { return pile_->GetFlattenedPicture(); } void PictureLayerImpl::SetShouldUseGpuRasterization( bool should_use_gpu_rasterization) { if (should_use_gpu_rasterization != should_use_gpu_rasterization_) { should_use_gpu_rasterization_ = should_use_gpu_rasterization; RemoveAllTilings(); } else { should_use_gpu_rasterization_ = should_use_gpu_rasterization; } } scoped_refptr PictureLayerImpl::CreateTile(PictureLayerTiling* tiling, const gfx::Rect& content_rect) { if (!pile_->CanRaster(tiling->contents_scale(), content_rect)) return scoped_refptr(); int flags = 0; if (is_using_lcd_text_) flags |= Tile::USE_LCD_TEXT; if (should_use_gpu_rasterization()) flags |= Tile::USE_GPU_RASTERIZATION; return layer_tree_impl()->tile_manager()->CreateTile( pile_.get(), content_rect.size(), content_rect, contents_opaque() ? content_rect : gfx::Rect(), tiling->contents_scale(), id(), layer_tree_impl()->source_frame_number(), flags); } void PictureLayerImpl::UpdatePile(Tile* tile) { tile->set_picture_pile(pile_); } const Region* PictureLayerImpl::GetInvalidation() { return &invalidation_; } const PictureLayerTiling* PictureLayerImpl::GetTwinTiling( const PictureLayerTiling* tiling) const { 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; } 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 = layer_tree_impl()->resource_provider()->max_texture_size(); gfx::Size default_tile_size = layer_tree_impl()->settings().default_tile_size; default_tile_size.SetToMin(gfx::Size(max_texture_size, max_texture_size)); gfx::Size max_untiled_content_size = layer_tree_impl()->settings().max_untiled_layer_size; max_untiled_content_size.SetToMin( gfx::Size(max_texture_size, max_texture_size)); bool any_dimension_too_large = content_bounds.width() > max_untiled_content_size.width() || content_bounds.height() > max_untiled_content_size.height(); bool any_dimension_one_tile = content_bounds.width() <= default_tile_size.width() || content_bounds.height() <= default_tile_size.height(); // If long and skinny, tile at the max untiled content size, and clamp // the smaller dimension to the content size, e.g. 1000x12 layer with // 500x500 max untiled size would get 500x12 tiles. Also do this // if the layer is small. if (any_dimension_one_tile || !any_dimension_too_large) { int width = std::min(max_untiled_content_size.width(), content_bounds.width()); int height = std::min(max_untiled_content_size.height(), content_bounds.height()); // Round width and height up to the closest multiple of 64, or 56 if // we should avoid power-of-two textures. This helps reduce the number // of different textures sizes to help recycling, and also keeps all // textures multiple-of-eight, which is preferred on some drivers (IMG). bool avoid_pow2 = layer_tree_impl()->GetRendererCapabilities().avoid_pow2_textures; int round_up_to = avoid_pow2 ? 56 : 64; width = RoundUp(width, round_up_to); height = RoundUp(height, round_up_to); return gfx::Size(width, height); } return default_tile_size; } void PictureLayerImpl::SyncFromActiveLayer(const PictureLayerImpl* other) { DCHECK(!other->needs_post_commit_initialization_); DCHECK(other->tilings_); UpdateLCDTextStatus(other->is_using_lcd_text_); if (!DrawsContent()) { RemoveAllTilings(); return; } 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_; // Add synthetic invalidations for any recordings that were dropped. As // tiles are updated to point to this new pile, this will force the dropping // of tiles that can no longer be rastered. This is not ideal, but is a // trade-off for memory (use the same pile as much as possible, by switching // during DidBecomeActive) and for time (don't bother checking every tile // during activation to see if the new pile can still raster it). for (int x = 0; x < pile_->num_tiles_x(); ++x) { for (int y = 0; y < pile_->num_tiles_y(); ++y) { bool previously_had = other->pile_->HasRecordingAt(x, y); bool now_has = pile_->HasRecordingAt(x, y); if (now_has || !previously_had) continue; gfx::Rect layer_rect = pile_->tile_bounds(x, y); invalidation_.Union(layer_rect); } } // Union in the other newly exposed regions as invalid. Region difference_region = Region(gfx::Rect(bounds())); difference_region.Subtract(gfx::Rect(other->bounds())); invalidation_.Union(difference_region); if (CanHaveTilings()) { // The recycle tree's tiling set is two frames out of date, so it needs to // have both this frame's invalidation and the previous frame's invalidation // (stored on the active layer). Region tiling_invalidation = other->invalidation_; tiling_invalidation.Union(invalidation_); tilings_->SyncTilings(*other->tilings_, bounds(), tiling_invalidation, MinimumContentsScale()); } else { RemoveAllTilings(); } SanityCheckTilingState(); } void PictureLayerImpl::SyncTiling( const PictureLayerTiling* tiling) { if (!CanHaveTilingWithScale(tiling->contents_scale())) return; tilings_->AddTiling(tiling->contents_scale()); // If this tree needs update draw properties, then the tiling will // get updated prior to drawing or activation. If this tree does not // need update draw properties, then its transforms are up to date and // we can create tiles for this tiling immediately. if (!layer_tree_impl()->needs_update_draw_properties() && should_update_tile_priorities_) UpdateTilePriorities(); } void PictureLayerImpl::SetIsMask(bool is_mask) { if (is_mask_ == is_mask) return; is_mask_ = is_mask; if (tilings_) tilings_->RemoveAllTiles(); } ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const { gfx::Rect content_rect(content_bounds()); float scale = contents_scale_x(); PictureLayerTilingSet::CoverageIterator iter( tilings_.get(), scale, content_rect, ideal_contents_scale_); // Mask resource not ready yet. if (!iter || !*iter) return 0; // Masks only supported if they fit on exactly one tile. if (iter.geometry_rect() != content_rect) return 0; const ManagedTileState::TileVersion& tile_version = iter->GetTileVersionForDrawing(); if (!tile_version.IsReadyToDraw() || tile_version.mode() != ManagedTileState::TileVersion::RESOURCE_MODE) return 0; return tile_version.get_resource_id(); } void PictureLayerImpl::MarkVisibleResourcesAsRequired() const { DCHECK(layer_tree_impl()->IsPendingTree()); DCHECK(!layer_tree_impl()->needs_update_draw_properties()); DCHECK(ideal_contents_scale_); DCHECK_GT(tilings_->num_tilings(), 0u); // The goal of this function is to find the minimum set of tiles that need to // be ready to draw in order to activate without flashing content from a // higher res on the active tree to a lower res on the pending tree. gfx::Rect rect(visible_content_rect()); float min_acceptable_scale = std::min(raster_contents_scale_, ideal_contents_scale_); if (PictureLayerImpl* twin = twin_layer_) { float twin_min_acceptable_scale = std::min(twin->ideal_contents_scale_, twin->raster_contents_scale_); // Ignore 0 scale in case CalculateContentsScale() has never been // called for active twin. if (twin_min_acceptable_scale != 0.0f) { min_acceptable_scale = std::min(min_acceptable_scale, twin_min_acceptable_scale); } } PictureLayerTiling* high_res = NULL; PictureLayerTiling* low_res = NULL; // First pass: ready to draw tiles in acceptable but non-ideal tilings are // marked as required for activation so that their textures are not thrown // away; any non-ready tiles are not marked as required. Region missing_region = rect; for (size_t i = 0; i < tilings_->num_tilings(); ++i) { PictureLayerTiling* tiling = tilings_->tiling_at(i); DCHECK(tiling->has_ever_been_updated()); if (tiling->resolution() == LOW_RESOLUTION) { DCHECK(!low_res) << "There can only be one low res tiling"; low_res = tiling; } if (tiling->contents_scale() < min_acceptable_scale) continue; if (tiling->resolution() == HIGH_RESOLUTION) { DCHECK(!high_res) << "There can only be one high res tiling"; high_res = tiling; 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. const PictureLayerTiling* twin_high_res = NULL; const PictureLayerTiling* twin_low_res = NULL; // As a simplification, only allow activating to skip twin tiles that the // active layer is also missing when both this layer and its twin have 2 // tilings (high and low). This avoids having to iterate/track coverage of // non-ideal tilings during the last draw call on the active layer. if (high_res && low_res && tilings_->num_tilings() == 2 && twin_layer_ && twin_layer_->tilings_->num_tilings() == 2) { twin_low_res = GetTwinTiling(low_res); if (twin_low_res) twin_high_res = GetTwinTiling(high_res); } // If this layer and its twin have different transforms, then don't compare // them and only allow activating to high res tiles, since tiles on each layer // will be in different places on screen. if (!twin_high_res || !twin_low_res || twin_layer_->layer_tree_impl()->RequiresHighResToDraw() || draw_properties().screen_space_transform != twin_layer_->draw_properties().screen_space_transform) { twin_high_res = NULL; twin_low_res = NULL; } // As a second pass, mark as required any visible high res tiles not filled in // by acceptable non-ideal tiles from the first pass. if (MarkVisibleTilesAsRequired( high_res, twin_high_res, contents_scale_x(), rect, missing_region)) { // As an optional third pass, if a high res tile was skipped because its // twin was also missing, then fall back to mark low res tiles as required // in case the active twin is substituting those for missing high res // content. MarkVisibleTilesAsRequired( low_res, twin_low_res, contents_scale_x(), rect, missing_region); } } bool PictureLayerImpl::MarkVisibleTilesAsRequired( PictureLayerTiling* tiling, const PictureLayerTiling* optional_twin_tiling, float contents_scale, const gfx::Rect& rect, const Region& missing_region) const { bool twin_had_missing_tile = false; 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()); if (!twin_tile || twin_tile == tile) { twin_had_missing_tile = true; continue; } } tile->MarkRequiredForActivation(); } return twin_had_missing_tile; } void PictureLayerImpl::DoPostCommitInitialization() { DCHECK(needs_post_commit_initialization_); DCHECK(layer_tree_impl()->IsPendingTree()); if (!tilings_) tilings_.reset(new PictureLayerTilingSet(this, bounds())); DCHECK(!twin_layer_); twin_layer_ = static_cast( layer_tree_impl()->FindActiveTreeLayerById(id())); if (twin_layer_) { DCHECK(!twin_layer_->twin_layer_); twin_layer_->twin_layer_ = this; // 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; } PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) { DCHECK(CanHaveTilingWithScale(contents_scale)) << "contents_scale: " << contents_scale; PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale); const Region& recorded = pile_->recorded_region(); DCHECK(!recorded.IsEmpty()); if (twin_layer_ && twin_layer_->should_use_gpu_rasterization() == should_use_gpu_rasterization()) twin_layer_->SyncTiling(tiling); return tiling; } void PictureLayerImpl::RemoveTiling(float contents_scale) { 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; } } if (tilings_->num_tilings() == 0) ResetRasterScale(); SanityCheckTilingState(); } void PictureLayerImpl::RemoveAllTilings() { tilings_->RemoveAllTilings(); // If there are no tilings, then raster scales are no longer meaningful. 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::ManageTilings(bool animating_transform_to_screen) { DCHECK(ideal_contents_scale_); DCHECK(ideal_page_scale_); DCHECK(ideal_device_scale_); DCHECK(ideal_source_scale_); DCHECK(CanHaveTilings()); DCHECK(!needs_post_commit_initialization_); bool change_target_tiling = 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 || ShouldAdjustRasterScale(animating_transform_to_screen); if (tilings_->num_tilings() == 0) { DCHECK(change_target_tiling) << "A layer with no tilings shouldn't have valid raster scales"; } // Store the value for the next time ShouldAdjustRasterScale is called. raster_source_scale_was_animating_ = animating_transform_to_screen; if (!change_target_tiling) return; if (!layer_tree_impl()->device_viewport_valid_for_tile_management()) return; RecalculateRasterScales(animating_transform_to_screen); PictureLayerTiling* high_res = NULL; PictureLayerTiling* low_res = NULL; PictureLayerTiling* previous_low_res = NULL; for (size_t i = 0; i < tilings_->num_tilings(); ++i) { PictureLayerTiling* tiling = tilings_->tiling_at(i); if (tiling->contents_scale() == raster_contents_scale_) high_res = tiling; if (tiling->contents_scale() == low_res_raster_contents_scale_) low_res = tiling; if (tiling->resolution() == LOW_RESOLUTION) previous_low_res = tiling; // Reset all tilings to non-ideal until the end of this function. tiling->set_resolution(NON_IDEAL_RESOLUTION); } if (!high_res) { high_res = AddTiling(raster_contents_scale_); if (raster_contents_scale_ == low_res_raster_contents_scale_) low_res = high_res; } // Only create new low res tilings when the transform is static. This // prevents wastefully creating a paired low res tiling for every new high res // tiling during a pinch or a CSS animation. bool is_pinching = layer_tree_impl()->PinchGestureActive(); if (ShouldHaveLowResTiling() && !is_pinching && !animating_transform_to_screen && !low_res && low_res != high_res) low_res = AddTiling(low_res_raster_contents_scale_); // Set low-res if we have one. if (!low_res) low_res = previous_low_res; if (low_res && low_res != high_res) low_res->set_resolution(LOW_RESOLUTION); // Make sure we always have one high-res (even if high == low). high_res->set_resolution(HIGH_RESOLUTION); SanityCheckTilingState(); } bool PictureLayerImpl::ShouldAdjustRasterScale( bool animating_transform_to_screen) const { // TODO(danakj): Adjust raster source scale closer to ideal source scale at // 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. if (raster_source_scale_was_animating_ && !animating_transform_to_screen) return true; bool is_pinching = layer_tree_impl()->PinchGestureActive(); if (is_pinching && raster_page_scale_) { // We change our raster scale when it is: // - Higher than ideal (need a lower-res tiling available) // - Too far from ideal (need a higher-res tiling available) float ratio = ideal_page_scale_ / raster_page_scale_; if (raster_page_scale_ > ideal_page_scale_ || ratio > kMaxScaleRatioDuringPinch) return true; } if (!is_pinching) { // When not pinching, match the ideal page scale factor. if (raster_page_scale_ != ideal_page_scale_) return true; } // Always match the ideal device scale factor. if (raster_device_scale_ != ideal_device_scale_) return true; 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( bool animating_transform_to_screen) { raster_device_scale_ = ideal_device_scale_; raster_source_scale_ = ideal_source_scale_; bool is_pinching = layer_tree_impl()->PinchGestureActive(); if (!is_pinching || raster_contents_scale_ == 0.f) { // When not pinching or when we have no previous scale, we use ideal scale: raster_page_scale_ = ideal_page_scale_; raster_contents_scale_ = ideal_contents_scale_; } else { // See ShouldAdjustRasterScale: // - When zooming out, preemptively create new tiling at lower resolution. // - When zooming in, approximate ideal using multiple of kMaxScaleRatio. bool zooming_out = raster_page_scale_ > ideal_page_scale_; float desired_contents_scale = zooming_out ? raster_contents_scale_ / kMaxScaleRatioDuringPinch : raster_contents_scale_ * kMaxScaleRatioDuringPinch; raster_contents_scale_ = SnappedContentsScale(desired_contents_scale); raster_page_scale_ = raster_contents_scale_ / raster_device_scale_; } raster_contents_scale_ = std::max(raster_contents_scale_, MinimumContentsScale()); // Don't allow animating CSS scales to drop below 1. This is needed because // changes in raster source scale aren't handled. See the comment in // ShouldAdjustRasterScale. if (animating_transform_to_screen) { raster_contents_scale_ = std::max( raster_contents_scale_, 1.f * ideal_page_scale_ * ideal_device_scale_); } // If this layer would only create one tile at this content scale, // don't create a low res tiling. gfx::Size content_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), raster_contents_scale_)); gfx::Size tile_size = CalculateTileSize(content_bounds); if (tile_size.width() >= content_bounds.width() && tile_size.height() >= content_bounds.height()) { low_res_raster_contents_scale_ = raster_contents_scale_; return; } float low_res_factor = layer_tree_impl()->settings().low_res_contents_scale_factor; low_res_raster_contents_scale_ = std::max( raster_contents_scale_ * low_res_factor, MinimumContentsScale()); } void PictureLayerImpl::CleanUpTilingsOnActiveLayer( std::vector used_tilings) { DCHECK(layer_tree_impl()->IsActiveTree()); if (tilings_->num_tilings() == 0) return; float min_acceptable_high_res_scale = std::min( raster_contents_scale_, ideal_contents_scale_); float max_acceptable_high_res_scale = std::max( raster_contents_scale_, ideal_contents_scale_); PictureLayerImpl* twin = twin_layer_; if (twin) { min_acceptable_high_res_scale = std::min( min_acceptable_high_res_scale, std::min(twin->raster_contents_scale_, twin->ideal_contents_scale_)); max_acceptable_high_res_scale = std::max( max_acceptable_high_res_scale, std::max(twin->raster_contents_scale_, twin->ideal_contents_scale_)); } std::vector to_remove; for (size_t i = 0; i < tilings_->num_tilings(); ++i) { PictureLayerTiling* tiling = tilings_->tiling_at(i); // Keep multiple high resolution tilings even if not used to help // activate earlier at non-ideal resolutions. if (tiling->contents_scale() >= min_acceptable_high_res_scale && tiling->contents_scale() <= max_acceptable_high_res_scale) continue; // Keep low resolution tilings, if the layer should have them. if (tiling->resolution() == LOW_RESOLUTION && ShouldHaveLowResTiling()) continue; // Don't remove tilings that are being used (and thus would cause a flash.) if (std::find(used_tilings.begin(), used_tilings.end(), tiling) != used_tilings.end()) continue; to_remove.push_back(tiling); } for (size_t i = 0; i < to_remove.size(); ++i) { const PictureLayerTiling* twin_tiling = GetTwinTiling(to_remove[i]); // Only remove tilings from the twin layer if they have // NON_IDEAL_RESOLUTION. if (twin_tiling && twin_tiling->resolution() == NON_IDEAL_RESOLUTION) twin->RemoveTiling(to_remove[i]->contents_scale()); tilings_->Remove(to_remove[i]); } DCHECK_GT(tilings_->num_tilings(), 0u); SanityCheckTilingState(); } float PictureLayerImpl::MinimumContentsScale() const { float setting_min = layer_tree_impl()->settings().minimum_contents_scale; // If the contents scale is less than 1 / width (also for height), // then it will end up having less than one pixel of content in that // dimension. Bump the minimum contents scale up in this case to prevent // this from happening. int min_dimension = std::min(bounds().width(), bounds().height()); if (!min_dimension) return setting_min; return std::max(1.f / min_dimension, setting_min); } void PictureLayerImpl::UpdateLCDTextStatus(bool new_status) { // Once this layer is not using lcd text, don't switch back. if (!is_using_lcd_text_) return; if (is_using_lcd_text_ == new_status) return; is_using_lcd_text_ = new_status; tilings_->SetCanUseLCDText(is_using_lcd_text_); } void PictureLayerImpl::ResetRasterScale() { 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; // When raster scales aren't valid, don't update tile priorities until // this layer has been updated via UpdateDrawProperties. should_update_tile_priorities_ = false; } bool PictureLayerImpl::CanHaveTilings() const { if (!DrawsContent()) return false; if (pile_->recorded_region().IsEmpty()) return false; return true; } bool PictureLayerImpl::CanHaveTilingWithScale(float contents_scale) const { if (!CanHaveTilings()) return false; if (contents_scale < MinimumContentsScale()) return false; return true; } void PictureLayerImpl::SanityCheckTilingState() const { if (!DCHECK_IS_ON()) return; if (!CanHaveTilings()) { DCHECK_EQ(0u, tilings_->num_tilings()); return; } if (tilings_->num_tilings() == 0) return; // MarkVisibleResourcesAsRequired depends on having exactly 1 high res // tiling to mark its tiles as being required for activation. DCHECK_EQ(1, tilings_->NumHighResTilings()); } void PictureLayerImpl::GetDebugBorderProperties( SkColor* color, float* width) const { *color = DebugColors::TiledContentLayerBorderColor(); *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl()); } void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const { const_cast(this)->DoPostCommitInitializationIfNeeded(); LayerImpl::AsValueInto(state); state->SetDouble("ideal_contents_scale", ideal_contents_scale_); state->SetDouble("geometry_contents_scale", contents_scale_x()); state->Set("tilings", tilings_->AsValue().release()); state->Set("pictures", pile_->AsValue().release()); state->Set("invalidation", invalidation_.AsValue().release()); Region unrecorded_region(gfx::Rect(pile_->size())); unrecorded_region.Subtract(pile_->recorded_region()); if (!unrecorded_region.IsEmpty()) state->Set("unrecorded_region", unrecorded_region.AsValue().release()); scoped_ptr coverage_tiles(new base::ListValue); for (PictureLayerTilingSet::CoverageIterator iter(tilings_.get(), contents_scale_x(), gfx::Rect(content_bounds()), ideal_contents_scale_); iter; ++iter) { scoped_ptr tile_data(new base::DictionaryValue); tile_data->Set("geometry_rect", MathUtil::AsValue(iter.geometry_rect()).release()); if (*iter) tile_data->Set("tile", TracedValue::CreateIDRef(*iter).release()); coverage_tiles->Append(tile_data.release()); } state->Set("coverage_tiles", coverage_tiles.release()); state->SetBoolean("is_using_lcd_text", is_using_lcd_text_); } size_t PictureLayerImpl::GPUMemoryUsageInBytes() const { const_cast(this)->DoPostCommitInitializationIfNeeded(); return tilings_->GPUMemoryUsageInBytes(); } void PictureLayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) { benchmark->RunOnLayer(this); } } // namespace cc