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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 24 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) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // Already in front.
   MoveAbove(child, children_.back());
+
+  SetNeedsToRecomputeHole();
 }
 
 void Layer::MoveAbove(Layer* child, Layer* other) {
   DCHECK_NE(child, other);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, other->parent());
   size_t child_i =
       std::find(children_.begin(), children_.end(), child) - children_.begin();
   size_t other_i =
       std::find(children_.begin(), children_.end(), other) - children_.begin();
   if (child_i > other_i)
     return;  // Already in front of |other|.
 
   // Reorder children.
   children_.erase(children_.begin() + child_i);
   children_.insert(children_.begin() + other_i, child);
 
+  SetNeedsToRecomputeHole();
+
 #if defined(USE_WEBKIT_COMPOSITOR)
   child->web_layer_.removeFromParent();
   web_layer_.insertChild(child->web_layer_, other_i);
 #endif
 }
 
 bool Layer::Contains(const Layer* other) const {
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
@@ skipping 52 matching lines @@
 #if defined(USE_WEBKIT_COMPOSITOR)
   // TODO(piman): Expose a visibility flag on WebLayer.
   web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
 #endif
   bool is_drawn = IsDrawn();
   if (was_drawn == is_drawn)
     return;
 
   if (!is_drawn)
     DropTextures();
-  if (parent_)
-    parent_->RecomputeHole();
+  SetNeedsToRecomputeHole();
 }
 
 bool Layer::IsDrawn() const {
   const Layer* layer = this;
   while (layer && layer->visible_)
     layer = layer->parent_;
   return layer == NULL;
 }
 
 bool Layer::ShouldDraw() const {
@@ skipping 16 matching lines @@
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 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;
 #if defined(USE_WEBKIT_COMPOSITOR)
@@ skipping 58 matching lines @@
   if (compositor)
     compositor->ScheduleDraw();
 }
 
 void Layer::Draw() {
   TRACE_EVENT0("ui", "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 87 matching lines @@
     return;
   }
   scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvas(draw_rect.size(),
                                                            false));
   canvas->Translate(gfx::Point().Subtract(draw_rect.origin()));
   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::GetLayerProperties(const ui::Transform& parent_transform,
+                               std::vector<LayerProperties>* traversal) {
+  if (!visible_ || opacity_ != 1.0f)
     return;
 
-  // Reset to default.
-  hole_rect_ = gfx::Rect();
+  ui::Transform current_transform;
+  if (transform().HasChange())
+    current_transform.ConcatTransform(transform());
+  current_transform.ConcatTranslate(
+      static_cast<float>(bounds().x()),
+      static_cast<float>(bounds().y()));
+  current_transform.ConcatTransform(parent_transform);
 
-  // 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;
-
-    // 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;
-
-    // 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);
-
-    // 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;
+  if (fills_bounds_opaquely_ && type_ == LAYER_HAS_TEXTURE) {
+    LayerProperties properties;
+    properties.layer = this;
+    properties.transform_relative_to_root = current_transform;
+    traversal->push_back(properties);
   }
 
-  // Free up texture memory if the hole fills bounds of layer.
-  if (!ShouldDraw() && !layer_updated_externally_)
-    texture_ = NULL;
+  for (size_t i = 0; i < children_.size(); i++)
+    children_[i]->GetLayerProperties(current_transform, traversal);
+}
+
+void Layer::RecomputeHole() {
+  std::vector<LayerProperties> traversal;
+  ui::Transform transform;
+
+  ClearHoleRects();
+  GetLayerProperties(transform, &traversal);
+
+  for (size_t i = 0; i < traversal.size(); i++) {
+    Layer* layer = traversal[i].layer;
+    gfx::Rect bounds = gfx::Rect(layer->bounds().size());
+
+    // Iterate through layers which are after traversal[i] in draw order
+    // and find the largest candidate hole.
+    for (size_t j = i + 1; j < traversal.size(); j++) {
+      gfx::Rect candidate_hole = gfx::Rect(traversal[j].layer->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(
+          traversal[j].transform_relative_to_root);
+
+      if (!traversal[i].transform_relative_to_root.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;
+
+      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();
+    layer->RecomputeDrawsContent();
 #endif
-}
+  }
 
-bool Layer::IsCompletelyOpaque() const {
-  return fills_bounds_opaquely() && GetCombinedOpacity() == 1.0f;
+  recompute_hole_ = false;
 }
 
 // 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::DropTextures() {
+void Layer::DropTexture() {
   if (!layer_updated_externally_)
     texture_ = NULL;
+}
+
+void Layer::DropTextures() {
+  DropTexture();
   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);
   transform.TransformPoint(p);
@@ skipping 29 matching lines @@
 
   bool was_move = bounds_.size() == bounds.size();
   bounds_ = bounds;
   if (IsDrawn()) {
     if (was_move)
       ScheduleDraw();
     else
       SchedulePaint(gfx::Rect(bounds.size()));
   }
 
-  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 schedule_draw = (opacity != opacity_ && IsDrawn());
   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));
-    }
-  }
+  if (was_opaque != is_opaque)
+    SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   if (visible_)
     web_layer_.setOpacity(opacity);
 #endif
   if (schedule_draw)
     ScheduleDraw();
 }
 
 void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
@@ skipping 52 matching lines @@
 #else
     unsigned int texture_id = 0;
 #endif
     web_layer_.to<WebKit::WebExternalTextureLayer>().setTextureId(
         should_draw ? texture_id : 0);
   }
 }
 #endif
 
 }  // namespace ui