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

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/scoped_ptr.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/point3.h"
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : compositor_(compositor),
       texture_(compositor->CreateTexture()),
       parent_(NULL),
       fills_bounds_opaquely_(false),
       delegate_(NULL) {

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

visible_(true)

 }
 
 Layer::~Layer() {
   if (parent_)
     parent_->Remove(this);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
 }
 
 void Layer::Add(Layer* child) {
@@ skipping 79 matching lines @@
   texture_->SetCanvas(canvas, origin, bounds_.size());
   invalid_rect_ = gfx::Rect();
 }
 
 void Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   invalid_rect_ = invalid_rect_.Union(invalid_rect);
   compositor_->SchedulePaint();
 }
 
 void Layer::Draw() {
+  if (!visible_)
+    return;
+
   UpdateLayerCanvas();
 
   ui::TextureDrawParams texture_draw_params;
   for (Layer* layer = this; layer; layer = layer->parent_) {
     texture_draw_params.transform.ConcatTransform(layer->transform_);
     texture_draw_params.transform.ConcatTranslate(
         static_cast<float>(layer->bounds_.x()),
         static_cast<float>(layer->bounds_.y()));
   }
 
@@ skipping 23 matching lines @@
       hole_rect_.height()));
 
   // bottom
   DrawRegion(texture_draw_params, gfx::Rect(
       0,
       hole_rect_.bottom(),
       bounds_.width(),
       bounds_.height() - hole_rect_.bottom()));
 }
 
+void Layer::DrawTree() {
+  Draw();
+  for (size_t i = 0; i < children_.size(); ++i)

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

I don't think you want to paint children if this is !visible_.

+    children_.at(i)->DrawTree();
+}
+
 void Layer::DrawRegion(const ui::TextureDrawParams& params,
                        const gfx::Rect& region_to_draw) {
   if (!region_to_draw.IsEmpty())
     texture_->Draw(params, region_to_draw);
 }
 
 void Layer::UpdateLayerCanvas() {
   // If we have no delegate, that means that whoever constructed the Layer is
   // setting its canvas directly with SetCanvas().
   if (!delegate_)
     return;
   gfx::Rect local_bounds = gfx::Rect(gfx::Point(), bounds_.size());
   gfx::Rect draw_rect = invalid_rect_.Intersect(local_bounds);
   if (draw_rect.IsEmpty()) {
     invalid_rect_ = gfx::Rect();
     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_->OnPaint(canvas.get());
+  delegate_->OnPaintLayer(canvas.get());
   SetCanvas(*canvas->AsCanvasSkia(), bounds().origin());
 }
 
 void Layer::RecomputeHole() {
   for (size_t i = 0; i < children_.size(); ++i) {
     if (children_[i]->fills_bounds_opaquely() &&
         !children_[i]->transform().HasChange()) {
       hole_rect_ = children_[i]->bounds();
       return;
     }
@@ skipping 28 matching lines @@
   for (; p && p != ancestor; p = p->parent()) {
     if (p->transform().HasChange())
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
 }  // namespace ui