Rework View Layer Draw() to use the Layer::DrawTree() method and the LayerDelegate.

views/view.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 "views/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 352 matching lines @@
 }
 
 int View::GetHeightForWidth(int w) {
   if (layout_manager_.get())
     return layout_manager_->GetPreferredHeightForWidth(this, w);
   return GetPreferredSize().height();
 }
 
 void View::SetVisible(bool visible) {
   if (visible != visible_) {
-    // If the tab is currently visible, schedule paint to refresh parent.
+    // If the View is currently visible, schedule paint to refresh parent.
     if (visible_)
       SchedulePaint();
 
     visible_ = visible;
 
     if (visible_)
       CreateLayerIfNecessary();
     else
-      // Destroy layer if tab is invisible as invisible tabs never paint
+      // Destroy layer if the View is invisible as invisible Views never paint.
       DestroyLayerRecurse();
 
     // This notifies all sub-views recursively.
     PropagateVisibilityNotifications(this, visible_);
 
     // If we are newly visible, schedule paint.
     if (visible_)
       SchedulePaint();
   }
 }
@@ skipping 281 matching lines @@
     x_rect = v->ConvertRectToParent(x_rect);
   return x_rect;
 }
 
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaint() {
   SchedulePaintInRect(GetLocalBounds());
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {

[sky, 2011/09/13 17:47:06]

All the scheduling paint code (SchedulePaintInRect, MarkLayerDirty,
SchedulePaintInternal) should be updated. I believe what you'll want is once you
hit a view with a layer to forward to the layer and stop, otherwise continue up.

   if (!IsVisible() || !painting_enabled_)
     return;
 
   MarkLayerDirty();
   SchedulePaintInternal(rect);
 }
 
 void View::Paint(gfx::Canvas* canvas) {
   TRACE_EVENT0("View", "Paint");
-  if (!IsVisible() || !painting_enabled_)
+
+  ScopedCanvas scoped_canvas(canvas);
+
+  // Paint this View and its children, setting the clip rect to the bounds
+  // of this View and translating the origin to the local bounds' top left
+  // point.
+  //
+  // Note that the X (or left) position we pass to ClipRectInt takes into
+  // consideration whether or not the view uses a right-to-left layout so that
+  // we paint our view in its mirrored position if need be.
+  if (!canvas->ClipRectInt(GetMirroredX(), y(),
+                           width() - static_cast<int>(clip_x_),
+                           height() - static_cast<int>(clip_y_))) {
     return;
+  }
+  // Non-empty clip, translate the graphics such that 0,0 corresponds to
+  // where this view is located (related to its parent).
+  canvas->TranslateInt(GetMirroredX(), y());
 
-  ScopedCanvas scoped_canvas(NULL);
-  scoped_ptr<gfx::Canvas> layer_canvas;
-  gfx::Rect layer_rect;
+  if (transform())
+    canvas->Transform(*transform());
 
-  if (layer()) {
-    gfx::Rect dirty_rect;
-    if (!layer_helper_->clip_rect().IsEmpty()) {
-      dirty_rect = layer_helper_->clip_rect();
-    } else {
-      // TODO: clip against dirty rect of canvas (if canvas is non-null).
-      dirty_rect = gfx::Rect(0, 0, width(), height());
-    }
-    if (dirty_rect.IsEmpty())
-      return;
-
-    if (!layer_helper_->bitmap_needs_updating()) {
-      // We don't need to be painted. Iterate over descendants in case one of
-      // them is dirty.
-      PaintToLayer(dirty_rect);
-      return;
-    }
-
-    layer_canvas.reset(gfx::Canvas::CreateCanvas(dirty_rect.width(),
-        dirty_rect.height(), false));
-    layer_canvas->AsCanvasSkia()->drawColor(
-        SK_ColorBLACK, SkXfermode::kClear_Mode);
-    layer_canvas->TranslateInt(-dirty_rect.x(), -dirty_rect.y());
-    canvas = layer_canvas.get();
-    layer_rect = dirty_rect;
-  } else {
-    // We're going to modify the canvas, save its state first.
-    scoped_canvas.SetCanvas(canvas);
-
-    // Paint this View and its children, setting the clip rect to the bounds
-    // of this View and translating the origin to the local bounds' top left
-    // point.
-    //
-    // Note that the X (or left) position we pass to ClipRectInt takes into
-    // consideration whether or not the view uses a right-to-left layout so that
-    // we paint our view in its mirrored position if need be.
-    if (!canvas->ClipRectInt(GetMirroredX(), y(),
-                             width() - static_cast<int>(clip_x_),
-                             height() - static_cast<int>(clip_y_))) {
-      return;
-    }
-    // Non-empty clip, translate the graphics such that 0,0 corresponds to
-    // where this view is located (related to its parent).
-    canvas->TranslateInt(GetMirroredX(), y());
-
-    if (transform())
-      canvas->Transform(*transform());
-  }
-
-  {
-    // If the View we are about to paint requested the canvas to be flipped, we
-    // should change the transform appropriately.
-    // The canvas mirroring is undone once the View is done painting so that we
-    // don't pass the canvas with the mirrored transform to Views that didn't
-    // request the canvas to be flipped.
-
-    ScopedCanvas scoped(canvas);
-    if (FlipCanvasOnPaintForRTLUI()) {
-      canvas->TranslateInt(width(), 0);
-      canvas->ScaleInt(-1, 1);
-    }
-
-    OnPaint(canvas);
-  }
-
-  PaintChildren(canvas);
-
-  if (layer_canvas.get()) {
-    layer()->SetCanvas(*layer_canvas->AsCanvasSkia(), layer_rect.origin());
-    layer_helper_->set_bitmap_needs_updating(false);
-  }
+  PaintCommon(canvas);
 }
 
 ThemeProvider* View::GetThemeProvider() const {
   const Widget* widget = GetWidget();
   return widget ? widget->GetThemeProvider() : NULL;
 }
 
 // Accelerated Painting --------------------------------------------------------
 
 // static
@@ skipping 368 matching lines @@
     border_->Paint(*this, canvas);
 }
 
 void View::OnPaintFocusBorder(gfx::Canvas* canvas) {
   if ((IsFocusable() || IsAccessibilityFocusableInRootView()) && HasFocus())
     canvas->DrawFocusRect(0, 0, width(), height());
 }
 
 // Accelerated Painting --------------------------------------------------------
 
-void View::PaintComposite() {
-  if (!IsVisible())
-    return;
-
-  if (layer()) {
-    OnWillCompositeLayer();
-    layer()->Draw();
-  }
-
-  for (int i = 0, count = child_count(); i < count; ++i)
-    child_at(i)->PaintComposite();
-}
-
 void View::SchedulePaintInternal(const gfx::Rect& rect) {
   if (parent_ && parent_->IsVisible() && painting_enabled_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     parent_->SchedulePaintInternal(ConvertRectToParent(rect));
   }
 }
 
-void View::PaintToLayer(const gfx::Rect& dirty_region) {
-  if (!IsVisible())
-    return;
-
-  if (layer() && layer_helper_->bitmap_needs_updating()) {
-    if (!layer_helper_->needs_paint_all())
-      layer_helper_->set_clip_rect(dirty_region);
-    else
-      layer_helper_->set_needs_paint_all(false);
-    Paint(NULL);
-    layer_helper_->set_clip_rect(gfx::Rect());
-  } else {
-    // Forward to all children as a descendant may be dirty and have a layer.
-    for (int i = child_count() - 1; i >= 0; --i) {
-      View* child_view = child_at(i);
-
-      gfx::Rect child_dirty_rect = dirty_region;
-      child_dirty_rect.Offset(-child_view->GetMirroredX(), -child_view->y());
-      child_view->GetTransform().TransformRectReverse(&child_dirty_rect);
-      child_dirty_rect = gfx::Rect(gfx::Point(), child_view->size()).Intersect(
-          child_dirty_rect);
-
-      if (!child_dirty_rect.IsEmpty())
-        child_at(i)->PaintToLayer(child_dirty_rect);
-    }
-  }
-}
-
-void View::OnWillCompositeLayer() {
-}
-
 void View::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (!layer_helper_.get())
     layer_helper_.reset(new internal::LayerHelper());
 
   layer_helper_->set_fills_bounds_opaquely(fills_bounds_opaquely);
 
   if (layer())
     layer()->SetFillsBoundsOpaquely(fills_bounds_opaquely);
 }
 
@@ skipping 13 matching lines @@
     return false;
 
   // Child views must not paint into the external texture. So make sure each
   // child view has its own layer to paint into.
   if (use_external) {
     for (Views::iterator i = children_.begin(); i != children_.end(); ++i)
       (*i)->SetPaintToLayer(true);
   }
 
   layer_helper_->set_layer_updated_externally(use_external);
-  layer_helper_->set_bitmap_needs_updating(!use_external);
   if (layer())
     layer()->SetTexture(texture);
 
   if (IsVisible())
     SchedulePaintInternal(GetLocalBounds());
 
   return true;
 }
 
 const ui::Compositor* View::GetCompositor() const {
   return parent_ ? parent_->GetCompositor() : NULL;
 }
 
 ui::Compositor* View::GetCompositor() {
   return parent_ ? parent_->GetCompositor() : NULL;
 }
 
 void View::MarkLayerDirty() {
   if (!use_acceleration_when_possible)
     return;
 
-  if (ShouldPaintToLayer()) {
-    if (!layer_helper_->layer_updated_externally())
-      layer_helper_->set_bitmap_needs_updating(true);
+  if (ShouldPaintToLayer())
     return;
-  }
   if (parent_)
     parent_->MarkLayerDirty();
 }
 
 void View::CalculateOffsetToAncestorWithLayer(gfx::Point* offset,
-                                              View** ancestor) {
+                                              ui::Layer** layer_parent) {
   if (layer()) {
-    if (ancestor)
-      *ancestor = this;
+    if (layer_parent)
+      *layer_parent = layer();
     return;
   }
   if (!parent_)
     return;
 
   offset->Offset(x(), y());
-  parent_->CalculateOffsetToAncestorWithLayer(offset, ancestor);
+  parent_->CalculateOffsetToAncestorWithLayer(offset, layer_parent);
 }
 
 void View::CreateLayerIfNecessary() {
   if (ShouldPaintToLayer())
     CreateLayer();
 
   for (int i = 0, count = child_count(); i < count; ++i)
     child_at(i)->CreateLayerIfNecessary();
 }
 
@@ skipping 23 matching lines @@
     layer_helper_->property_setter()->SetBounds(
         layer(),
         gfx::Rect(offset.x() + x(), offset.y() + y(), width(), height()));
   } else {
     gfx::Point new_offset(offset.x() + x(), offset.y() + y());
     for (int i = 0, count = child_count(); i < count; ++i)
       child_at(i)->UpdateLayerBounds(new_offset);
   }
 }
 
+void View::OnPaintLayer(gfx::Canvas* canvas) {
+  canvas->AsCanvasSkia()->drawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);

[sky, 2011/09/13 17:47:06]

We should ignore this if layer_helper_->layer_updated_externally()

+  PaintCommon(canvas);
+}
+
 // Input -----------------------------------------------------------------------
 
 bool View::HasHitTestMask() const {
   return false;
 }
 
 void View::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 }
 
@@ skipping 93 matching lines @@
     // If only the positions changes and we have a layer, we don't need to mark
     // the layer as dirty (which SchedulePaint does), only paint the bounds.
     SchedulePaintInternal(gfx::Rect(0, 0, width(), height()));
   } else {
     // If the size changes, or we don't have a layer then we need to use
     // SchedulePaint to make sure the layer is marked as dirty.
     SchedulePaint();
   }
 }
 
+void View::PaintCommon(gfx::Canvas* canvas) {
+  if (!IsVisible() || !painting_enabled_)
+    return;
+
+  {
+    // If the View we are about to paint requested the canvas to be flipped, we
+    // should change the transform appropriately.
+    // The canvas mirroring is undone once the View is done painting so that we
+    // don't pass the canvas with the mirrored transform to Views that didn't
+    // request the canvas to be flipped.
+    ScopedCanvas scoped(canvas);
+    if (FlipCanvasOnPaintForRTLUI()) {
+      canvas->TranslateInt(width(), 0);
+      canvas->ScaleInt(-1, 1);
+    }
+
+    OnPaint(canvas);
+  }
+
+  PaintChildren(canvas);
+}
+
 // Tree operations -------------------------------------------------------------
 
 void View::DoRemoveChildView(View* view,
                              bool update_focus_cycle,
                              bool update_tool_tip,
                              bool delete_removed_view) {
   DCHECK(view);
   const Views::iterator i(std::find(children_.begin(), children_.end(), view));
   scoped_ptr<View> view_to_be_deleted;
   if (i != children_.end()) {
@@ skipping 297 matching lines @@
 void View::CreateLayer() {
   if (!ShouldPaintToLayer() || layer())
     return;
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor)
     return;
 
   DCHECK(layer_helper_.get());
 
-  View* ancestor_with_layer = NULL;
+  ui::Layer* layer_parent = NULL;
   gfx::Point offset;
-  CalculateOffsetToAncestorWithLayer(&offset, &ancestor_with_layer);
+  CalculateOffsetToAncestorWithLayer(&offset, &layer_parent);
 
-  DCHECK(ancestor_with_layer || parent_ == NULL);
+  DCHECK(layer_parent || parent_ == NULL);
 
   layer_helper_->SetLayer(new ui::Layer(compositor));
+  layer()->set_delegate(this);
   layer()->SetFillsBoundsOpaquely(layer_helper_->fills_bounds_opaquely());
   layer()->SetBounds(gfx::Rect(offset.x(), offset.y(), width(), height()));
   layer()->SetTransform(GetTransform());
-  if (ancestor_with_layer)
-    ancestor_with_layer->layer()->Add(layer());
-  layer_helper_->set_bitmap_needs_updating(true);
+  if (layer_parent)
+    layer_parent->Add(layer());
   layer_helper_->set_needs_paint_all(true);

[sky, 2011/09/13 17:47:06]

It seems like this should somehow be combined with the invalid_rect_ in the
layer.

 
   MoveLayerToParent(layer(), gfx::Point());
 }
 
 void View::DestroyLayerAndReparent() {
   if (!layer())
     return;
 
   ui::Layer* new_parent = layer()->parent();
   std::vector<ui::Layer*> children = layer()->children();
@@ skipping 281 matching lines @@
     result.append(child_at(i)->PrintViewGraph(false));
 
   if (first)
     result.append("}\n");
 
   return result;
 }
 #endif
 
 }  // namespace views