| // Copyright 2016 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 "ui/accelerated_widget_mac/gl_renderer_layer_tree.h" |
| |
| #include "base/command_line.h" |
| #include "base/mac/scoped_nsobject.h" |
| #include "base/mac/sdk_forward_declarations.h" |
| #include "base/trace_event/trace_event.h" |
| #include "ui/base/ui_base_switches.h" |
| #include "ui/gfx/transform.h" |
| |
| @interface CALayer(Private) |
| -(void)setContentsChanged; |
| @end |
| |
| namespace ui { |
| namespace { |
| |
| // When selecting a CALayer to re-use for partial damage, this is the maximum |
| // fraction of the merged layer's pixels that may be not-updated by the swap |
| // before we consider the CALayer to not be a good enough match, and create a |
| // new one. |
| const float kMaximumPartialDamageWasteFraction = 1.2f; |
| |
| // The maximum number of partial damage layers that may be created before we |
| // give up and remove them all (doing full damage in the process). |
| const size_t kMaximumPartialDamageLayers = 8; |
| |
| } // namespace |
| |
| class GLRendererLayerTree::OverlayPlane { |
| public: |
| OverlayPlane(base::ScopedCFTypeRef<IOSurfaceRef> io_surface, |
| const gfx::Rect& pixel_frame_rect, |
| const gfx::RectF& contents_rect) |
| : io_surface(io_surface), |
| contents_rect(contents_rect), |
| pixel_frame_rect(pixel_frame_rect), |
| layer_needs_update(true) {} |
| |
| ~OverlayPlane() { |
| [ca_layer setContents:nil]; |
| [ca_layer removeFromSuperlayer]; |
| ca_layer.reset(); |
| } |
| |
| const base::ScopedCFTypeRef<IOSurfaceRef> io_surface; |
| const gfx::RectF contents_rect; |
| const gfx::Rect pixel_frame_rect; |
| bool layer_needs_update; |
| base::scoped_nsobject<CALayer> ca_layer; |
| |
| void TakeCALayerFrom(OverlayPlane* other_plane) { |
| ca_layer.swap(other_plane->ca_layer); |
| } |
| |
| void UpdateProperties(float scale_factor) { |
| if (layer_needs_update) { |
| [ca_layer setOpaque:YES]; |
| |
| id new_contents = static_cast<id>(io_surface.get()); |
| if ([ca_layer contents] == new_contents) |
| [ca_layer setContentsChanged]; |
| else |
| [ca_layer setContents:new_contents]; |
| [ca_layer setContentsRect:contents_rect.ToCGRect()]; |
| |
| [ca_layer setAnchorPoint:CGPointZero]; |
| |
| if ([ca_layer respondsToSelector:(@selector(setContentsScale:))]) |
| [ca_layer setContentsScale:scale_factor]; |
| gfx::RectF dip_frame_rect = gfx::RectF(pixel_frame_rect); |
| dip_frame_rect.Scale(1 / scale_factor); |
| [ca_layer setBounds:CGRectMake(0, 0, dip_frame_rect.width(), |
| dip_frame_rect.height())]; |
| [ca_layer |
| setPosition:CGPointMake(dip_frame_rect.x(), dip_frame_rect.y())]; |
| } |
| static bool show_borders = |
| base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kShowMacOverlayBorders); |
| if (show_borders) { |
| base::ScopedCFTypeRef<CGColorRef> color; |
| if (!layer_needs_update) { |
| // Green represents contents that are unchanged across frames. |
| color.reset(CGColorCreateGenericRGB(0, 1, 0, 1)); |
| } else { |
| // Red represents damaged contents. |
| color.reset(CGColorCreateGenericRGB(1, 0, 0, 1)); |
| } |
| [ca_layer setBorderWidth:1]; |
| [ca_layer setBorderColor:color]; |
| } |
| layer_needs_update = false; |
| } |
| |
| private: |
| }; |
| |
| void GLRendererLayerTree::UpdatePartialDamagePlanes( |
| GLRendererLayerTree* old_tree, |
| const gfx::Rect& pixel_damage_rect) { |
| // Don't create partial damage layers if partial swap is disabled. |
| if (!allow_partial_swap_) |
| return; |
| // Only create partial damage layers when building on top of an existing tree. |
| if (!old_tree) |
| return; |
| // If the frame size has changed, discard all of the old partial damage |
| // layers. |
| if (old_tree->root_plane_->pixel_frame_rect != root_plane_->pixel_frame_rect) |
| return; |
| // If there is full damage, discard all of the old partial damage layers. |
| if (pixel_damage_rect == root_plane_->pixel_frame_rect) |
| return; |
| |
| // If there is no damage, don't change anything. |
| if (pixel_damage_rect.IsEmpty()) { |
| std::swap(partial_damage_planes_, old_tree->partial_damage_planes_); |
| return; |
| } |
| |
| // Find the last partial damage plane to re-use the CALayer from. Grow the |
| // new rect for this layer to include this damage, and all nearby partial |
| // damage layers. |
| std::unique_ptr<OverlayPlane> plane_for_swap; |
| { |
| auto plane_to_reuse_iter = old_tree->partial_damage_planes_.end(); |
| gfx::Rect plane_to_reuse_enlarged_pixel_damage_rect; |
| |
| for (auto old_plane_iter = old_tree->partial_damage_planes_.begin(); |
| old_plane_iter != old_tree->partial_damage_planes_.end(); |
| ++old_plane_iter) { |
| gfx::Rect enlarged_pixel_damage_rect = |
| (*old_plane_iter)->pixel_frame_rect; |
| enlarged_pixel_damage_rect.Union(pixel_damage_rect); |
| |
| // Compute the fraction of the pixels that would not be updated by this |
| // swap. If it is too big, try another layer. |
| float waste_fraction = enlarged_pixel_damage_rect.size().GetArea() * 1.f / |
| pixel_damage_rect.size().GetArea(); |
| if (waste_fraction > kMaximumPartialDamageWasteFraction) |
| continue; |
| |
| plane_to_reuse_iter = old_plane_iter; |
| plane_to_reuse_enlarged_pixel_damage_rect.Union( |
| enlarged_pixel_damage_rect); |
| } |
| if (plane_to_reuse_iter != old_tree->partial_damage_planes_.end()) { |
| gfx::RectF enlarged_contents_rect = |
| gfx::RectF(plane_to_reuse_enlarged_pixel_damage_rect); |
| enlarged_contents_rect.Scale(1. / root_plane_->pixel_frame_rect.width(), |
| 1. / root_plane_->pixel_frame_rect.height()); |
| |
| plane_for_swap.reset(new OverlayPlane( |
| root_plane_->io_surface, plane_to_reuse_enlarged_pixel_damage_rect, |
| enlarged_contents_rect)); |
| |
| plane_for_swap->TakeCALayerFrom((*plane_to_reuse_iter).get()); |
| if (*plane_to_reuse_iter != old_tree->partial_damage_planes_.back()) { |
| CALayer* superlayer = [plane_for_swap->ca_layer superlayer]; |
| [plane_for_swap->ca_layer removeFromSuperlayer]; |
| [superlayer addSublayer:plane_for_swap->ca_layer]; |
| } |
| } |
| } |
| |
| // If we haven't found an appropriate layer to re-use, create a new one, if |
| // we haven't already created too many. |
| if (!plane_for_swap.get() && |
| old_tree->partial_damage_planes_.size() < kMaximumPartialDamageLayers) { |
| gfx::RectF contents_rect = gfx::RectF(pixel_damage_rect); |
| contents_rect.Scale(1. / root_plane_->pixel_frame_rect.width(), |
| 1. / root_plane_->pixel_frame_rect.height()); |
| plane_for_swap.reset(new OverlayPlane(root_plane_->io_surface, |
| pixel_damage_rect, contents_rect)); |
| } |
| |
| // And if we still don't have a layer, do full damage. |
| if (!plane_for_swap.get()) |
| return; |
| |
| // Walk all old partial damage planes. Remove anything that is now completely |
| // covered, and move everything else into the new |partial_damage_planes_|. |
| for (auto& old_plane : old_tree->partial_damage_planes_) { |
| if (!old_plane.get()) |
| continue; |
| // Intersect the planes' frames with the new root plane to ensure that |
| // they don't get kept alive inappropriately. |
| gfx::Rect old_plane_frame_rect = old_plane->pixel_frame_rect; |
| old_plane_frame_rect.Intersect(root_plane_->pixel_frame_rect); |
| |
| bool old_plane_covered_by_swap = false; |
| if (plane_for_swap.get() && |
| plane_for_swap->pixel_frame_rect.Contains(old_plane_frame_rect)) { |
| old_plane_covered_by_swap = true; |
| } |
| if (!old_plane_covered_by_swap) { |
| DCHECK(old_plane->ca_layer); |
| partial_damage_planes_.push_back(std::move(old_plane)); |
| } |
| } |
| |
| partial_damage_planes_.push_back(std::move(plane_for_swap)); |
| } |
| |
| void GLRendererLayerTree::UpdateRootAndPartialDamagePlanes( |
| std::unique_ptr<GLRendererLayerTree> old_tree, |
| const gfx::Rect& pixel_damage_rect) { |
| // First update the partial damage tree. |
| UpdatePartialDamagePlanes(old_tree.get(), pixel_damage_rect); |
| if (old_tree) { |
| if (partial_damage_planes_.empty()) { |
| // If there are no partial damage planes, then we will be updating the |
| // root layer. Take the CALayer from the old tree. |
| root_plane_->TakeCALayerFrom(old_tree->root_plane_.get()); |
| } else { |
| // If there is a partial damage tree, then just take the old plane |
| // from the previous frame, so that there is no update to it. |
| root_plane_.swap(old_tree->root_plane_); |
| } |
| } |
| } |
| |
| void GLRendererLayerTree::UpdateCALayers(CALayer* superlayer, |
| float scale_factor) { |
| if (!allow_partial_swap_) { |
| DCHECK(partial_damage_planes_.empty()); |
| return; |
| } |
| |
| // Allocate and update CALayers for the backbuffer and partial damage layers. |
| if (!root_plane_->ca_layer) { |
| DCHECK(partial_damage_planes_.empty()); |
| root_plane_->ca_layer.reset([[CALayer alloc] init]); |
| [superlayer setSublayers:nil]; |
| [superlayer addSublayer:root_plane_->ca_layer]; |
| } |
| // Excessive logging to debug white screens (crbug.com/583805). |
| // TODO(ccameron): change this back to a DLOG. |
| if ([root_plane_->ca_layer superlayer] != superlayer) { |
| LOG(ERROR) << "GLRendererLayerTree root layer not attached to tree."; |
| } |
| for (auto& plane : partial_damage_planes_) { |
| if (!plane->ca_layer) { |
| DCHECK(plane == partial_damage_planes_.back()); |
| plane->ca_layer.reset([[CALayer alloc] init]); |
| } |
| if (![plane->ca_layer superlayer]) { |
| DCHECK(plane == partial_damage_planes_.back()); |
| [superlayer addSublayer:plane->ca_layer]; |
| } |
| } |
| root_plane_->UpdateProperties(scale_factor); |
| for (auto& plane : partial_damage_planes_) |
| plane->UpdateProperties(scale_factor); |
| } |
| |
| GLRendererLayerTree::GLRendererLayerTree( |
| bool allow_partial_swap, |
| base::ScopedCFTypeRef<IOSurfaceRef> io_surface, |
| const gfx::Rect& pixel_frame_rect) |
| : allow_partial_swap_(allow_partial_swap) { |
| root_plane_.reset( |
| new OverlayPlane(io_surface, pixel_frame_rect, gfx::RectF(0, 0, 1, 1))); |
| } |
| |
| GLRendererLayerTree::~GLRendererLayerTree() {} |
| |
| base::ScopedCFTypeRef<IOSurfaceRef> |
| GLRendererLayerTree::RootLayerIOSurface() { |
| return root_plane_->io_surface; |
| } |
| |
| void GLRendererLayerTree::CommitCALayers( |
| CALayer* superlayer, |
| std::unique_ptr<GLRendererLayerTree> old_tree, |
| float scale_factor, |
| const gfx::Rect& pixel_damage_rect) { |
| TRACE_EVENT0("gpu", "GLRendererLayerTree::CommitCALayers"); |
| UpdateRootAndPartialDamagePlanes(std::move(old_tree), pixel_damage_rect); |
| UpdateCALayers(superlayer, scale_factor); |
| } |
| |
| } // namespace ui |