Improve Aura overdraw by changing hole calculation

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 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/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 18 matching lines @@
 }  // namespace
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : type_(LAYER_HAS_TEXTURE),
       compositor_(compositor),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
+      recompute_hole_(false),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
 #endif
 }
 
 Layer::Layer(Compositor* compositor, LayerType type)
     : type_(type),
       compositor_(compositor),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
+      recompute_hole_(false),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
 #endif
 }
 
 Layer::~Layer() {
   if (parent_)
@@ skipping 20 matching lines @@
 
 void Layer::Add(Layer* child) {
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.addChild(child->web_layer_);
 #endif
 
-  RecomputeHole();
+  SetNeedsToRecomputeHole();
 }
 
 void Layer::Remove(Layer* child) {
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
 #if defined(USE_WEBKIT_COMPOSITOR)
   child->web_layer_.removeFromParent();
 #endif
 
-  RecomputeHole();
+  SetNeedsToRecomputeHole();
 
   child->DropTextures();
 }
 
 void Layer::MoveToFront(Layer* child) {
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   children_.push_back(child);
@@ skipping 61 matching lines @@
     return;
 
   bool was_drawn = IsDrawn();
   visible_ = visible;
   bool is_drawn = IsDrawn();
   if (was_drawn == is_drawn)
     return;
 
   if (!is_drawn)
     DropTextures();
-  if (parent_)
-    parent_->RecomputeHole();
+  SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   // TODO(piman): Expose a visibility flag on WebLayer.
   web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
 #endif
 }
 
 bool Layer::IsDrawn() const {
   const Layer* layer = this;
   while (layer && layer->visible_)
     layer = layer->parent_;
@@ skipping 23 matching lines @@
     NOTREACHED(); // |source| and |target| are in unrelated hierarchies.
   }
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
-  if (parent())
-    parent()->RecomputeHole();
+  SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.setOpaque(fills_bounds_opaquely);
 #endif
 }
 
 void Layer::SetExternalTexture(ui::Texture* texture) {
   DCHECK(texture);
   layer_updated_externally_ = true;
   texture_ = texture;
 }
@@ skipping 29 matching lines @@
   Compositor* compositor = GetCompositor();
   if (compositor)
     compositor->ScheduleDraw();
 }
 
 void Layer::Draw() {
 #if defined(USE_WEBKIT_COMPOSITOR)
   NOTREACHED();
 #else
   DCHECK(GetCompositor());
+
+  if (recompute_hole_ && !parent_)
+    RecomputeHole();
+
   if (!ShouldDraw())
     return;
 
   UpdateLayerCanvas();
 
   // Layer drew nothing, no texture was created.
   if (!texture_.get())
     return;
 
   ui::TextureDrawParams texture_draw_params;
@@ skipping 85 matching lines @@
     return;
   }
   scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvas(
       draw_rect.width(), draw_rect.height(), false));
   canvas->TranslateInt(-draw_rect.x(), -draw_rect.y());
   delegate_->OnPaintLayer(canvas.get());
   SetCanvas(*canvas->GetSkCanvas(), draw_rect.origin());
 #endif
 }
 
-void Layer::RecomputeHole() {
-  if (type_ == LAYER_HAS_NO_TEXTURE)
+void Layer::SetNeedsToRecomputeHole() {
+  Layer* root_layer = this;
+  while (root_layer->parent_)
+    root_layer = root_layer->parent_;
+
+  root_layer->recompute_hole_ = true;
+}
+
+void Layer::ClearHoleRects() {
+  hole_rect_ = gfx::Rect();
+
+  for (size_t i = 0; i < children_.size(); i++)
+    children_[i]->ClearHoleRects();
+}
+
+void Layer::GeneratePreorderTraversal(
+    std::vector<ui::Layer*>* layer_traversal) {
+  if (!visible_)
     return;
 
-  // Reset to default.
-  hole_rect_ = gfx::Rect();
+  if (fills_bounds_opaquely_ && type_ == LAYER_HAS_TEXTURE)
+    layer_traversal->push_back(this);
 
-  // Find the largest hole
-  for (size_t i = 0; i < children_.size(); ++i) {
-    // Ignore non-opaque and hidden children.
-    if (!children_[i]->IsCompletelyOpaque() || !children_[i]->visible_)
-      continue;
+  for (size_t i = 0; i < children_.size(); i++)
+    children_[i]->GeneratePreorderTraversal(layer_traversal);
+}
 
-    // Ignore children that aren't rotated by multiples of 90 degrees.
-    float degrees;
-    if (!InterpolatedTransform::FactorTRS(children_[i]->transform(),
-                                          NULL, &degrees, NULL) ||
-        !IsApproximateMultilpleOf(degrees, 90.0f))
-      continue;
+void Layer::RecomputeHole() {
+  std::vector<ui::Layer*> layer_traversal;
+  std::vector<ui::Transform> transforms_relative_to_root;
+  std::vector<float> opacities;
 
-    // The reason why we don't just take the bounds and apply the transform is
-    // that the bounds encodes a position, too, so the effective transformation
-    // matrix is actually different that the one reported. As well, the bounds
-    // will not necessarily be at the origin.
-    gfx::Rect candidate_hole(children_[i]->bounds_.size());
-    ui::Transform transform = children_[i]->transform();
-    transform.ConcatTranslate(static_cast<float>(children_[i]->bounds_.x()),
-                              static_cast<float>(children_[i]->bounds_.y()));
-    transform.TransformRect(&candidate_hole);
+  ClearHoleRects();
+  GeneratePreorderTraversal(&layer_traversal);
 
-    // This layer might not contain the child (e.g., a portion of the child may
-    // be offscreen). Only the portion of the child that overlaps this layer is
-    // of any importance, so take the intersection.
-    candidate_hole = gfx::Rect(bounds().size()).Intersect(candidate_hole);
-
-    // Ensure we have the largest hole.
-    if (candidate_hole.size().GetArea() > hole_rect_.size().GetArea())
-      hole_rect_ = candidate_hole;
+  for (size_t i = 0; i < layer_traversal.size(); i++) {

[sky, 2011/10/24 23:25:50]

Seems a lot better to have GeneratePreorderTraversal generate all this for you.
That way GetCombinedOpacity and GetTransformRelativeTo aren't rewalking the
tree.

If you store the bounds of each layer relative to the root, do you even need to
store the transform? Wouldn't this also save computing this information multiple
times per layer?

+    Layer* layer = layer_traversal[i];
+    ui::Transform layer_transform;
+    layer->GetTransformRelativeTo(this, &layer_transform);
+    transforms_relative_to_root.push_back(layer_transform);
+    opacities.push_back(layer->GetCombinedOpacity());
   }
 
-  // Free up texture memory if the hole fills bounds of layer.
-  if (!ShouldDraw() && !layer_updated_externally_)
-    texture_ = NULL;
+  for (size_t i = 0; i < layer_traversal.size(); i++) {
+    Layer* layer = layer_traversal[i];
+    gfx::Rect bounds = gfx::Rect(layer->bounds().size());
+
+    // Iterate through layers which are after layer_traversal[i] in draw order
+    // and find the largest candidate hole.
+    for (size_t j = i + 1; j < layer_traversal.size(); j++) {
+      gfx::Rect candidate_hole = gfx::Rect(layer_traversal[j]->bounds().size());
+
+      // Compute transform to go from bounds of layer |j| to local bounds of
+      // layer |i|.
+      ui::Transform candidate_hole_transform;
+      ui::Transform inverted;
+
+      candidate_hole_transform.ConcatTransform(transforms_relative_to_root[j]);
+
+      if (!transforms_relative_to_root[i].GetInverse(&inverted))
+        continue;
+
+      candidate_hole_transform.ConcatTransform(inverted);
+
+      // cannot punch a hole if the relative transform between the two layers
+      // is not multiple of 90.
+      float degrees;
+      gfx::Point p;
+      if (!InterpolatedTransform::FactorTRS(candidate_hole_transform, &p,
+          &degrees, NULL) || !IsApproximateMultilpleOf(degrees, 90.0f))
+        continue;
+
+      // can only punch a hole if the two layers have 1.0f opacity.
+      if (opacities[i] != 1.0f || opacities[j] != 1.0f)

[sky, 2011/10/24 23:25:50]

This check is cheap. We should do it first.

+        continue;
+
+      candidate_hole_transform.TransformRect(&candidate_hole);
+      candidate_hole = candidate_hole.Intersect(bounds);
+
+      if (candidate_hole.size().GetArea() > layer->hole_rect().size().GetArea())
+        layer->set_hole_rect(candidate_hole);
+    }
+    // Free up texture memory if the hole fills bounds of layer.
+    if (!layer->ShouldDraw() && !layer_updated_externally())
+      layer->DropTexture();
 
 #if defined(USE_WEBKIT_COMPOSITOR)
-  RecomputeDrawsContent();
+    RecomputeDrawsContent();

[sky, 2011/10/24 23:25:50]

Shouldn't this be outside the for loop?

 #endif
-}
 
-bool Layer::IsCompletelyOpaque() const {
-  return fills_bounds_opaquely() && GetCombinedOpacity() == 1.0f;
+    recompute_hole_ = false;

[sky, 2011/10/24 23:25:50]

Shouldn't this be outside the for loop?

+  }
 }
 
 // static
 void Layer::PunchHole(const gfx::Rect& rect,
                       const gfx::Rect& region_to_punch_out,
                       std::vector<gfx::Rect>* sides) {
   gfx::Rect trimmed_rect = rect.Intersect(region_to_punch_out);
 
   if (trimmed_rect.IsEmpty()) {
     sides->push_back(rect);
@@ skipping 18 matching lines @@
                              rect.right() - trimmed_rect.right(),
                              trimmed_rect.height()));
 
   // Bottom (below the hole).
   sides->push_back(gfx::Rect(rect.x(),
                              trimmed_rect.bottom(),
                              rect.width(),
                              rect.bottom() - trimmed_rect.bottom()));
 }
 
+void Layer::DropTexture() {
+  if (!layer_updated_externally_)
+    texture_ = NULL;
+}
+
 void Layer::DropTextures() {
   if (!layer_updated_externally_)

[sky, 2011/10/24 23:25:50]

Change this to call DropTexture.

     texture_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->DropTextures();
 }
 
 bool Layer::ConvertPointForAncestor(const Layer* ancestor,
                                     gfx::Point* point) const {
   ui::Transform transform;
   bool result = GetTransformRelativeTo(ancestor, &transform);
   gfx::Point3f p(*point);
@@ skipping 43 matching lines @@
   if (property != LayerAnimationManager::TRANSFORM &&
       animator_->IsAnimating(LayerAnimationManager::TRANSFORM)) {
     SetTransformImmediately(animator_->GetTargetTransform());
   }
   animator_.reset();
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
-  if (parent())
-    parent()->RecomputeHole();
+  SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.setBounds(bounds.size());
   RecomputeTransform();
   RecomputeDrawsContent();
 #endif
 }
 
 void Layer::SetTransformImmediately(const ui::Transform& transform) {
   transform_ = transform;
 
-  if (parent())
-    parent()->RecomputeHole();
+  SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   RecomputeTransform();
 #endif
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
-  bool was_opaque = GetCombinedOpacity() == 1.0f;
   opacity_ = opacity;
-  bool is_opaque = GetCombinedOpacity() == 1.0f;
-
-  // If our opacity has changed we need to recompute our hole, our parent's hole
-  // and the holes of all our descendants.
-  if (was_opaque != is_opaque) {
-    if (parent_)
-      parent_->RecomputeHole();
-    std::queue<Layer*> to_process;
-    to_process.push(this);
-    while (!to_process.empty()) {
-      Layer* current = to_process.front();
-      to_process.pop();
-      current->RecomputeHole();
-      for (size_t i = 0; i < current->children_.size(); ++i)
-        to_process.push(current->children_.at(i));
-    }
-  }
+  SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   if (visible_)
     web_layer_.setOpacity(opacity);
   RecomputeDrawsContent();
 #endif
 }
 
 void Layer::SetBoundsFromAnimator(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
@@ skipping 88 matching lines @@
     result.append(", color=red");
 
   if (fills_bounds_opaquely())
     result.append(", style=filled");
 
   return result;
 }
 
 #endif
 
-////////////////////////////////////////////////////////////////////////////////
-
 }  // namespace ui