Use WebKit compositor in ui::Layer

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.

[jonathan.backer, 2011/10/18 15:28:26]

Just a high level comment (feel free to ignore). This code is going to get hard
to read. Seems to me that with compositor CC, most of the code here is ignored.
Maybe hide the two implementations behind a factory? Then it's obvious what code
is active where rather than having a trail of #ifdefs to decipher.

[Ben Goodger (Google), 2011/10/18 15:40:40]

Seems like we'd need to extract some of this code as a base then, since we have
lots of conversion/utility functions here too.

[piman, 2011/10/19 17:53:23]

If we were to support 2 compositors in the long run, I would look at
refactoring, but to do it properly is significant:
- making essentially all of layer's public API virtual, and giving hooks for
subclasses to do extra work
- move some of the logic into external reusable functions
- rework some tests that rely on inheriting from Layer

Since the 2 compositor case is only for a short period, I don't think it's a
good use of our time to do  that - the ifdefs can disappear within a 1-2 month
timeframe. So unless you feel very strongly, I'd rather not spend time on this.

I changed into #ifdefs making this more readable.

 // 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"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFloatPoint.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFloatRect.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "ui/base/animation/animation.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/point3.h"
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
 bool IsApproximateMultilpleOf(float value, float base) {
   float remainder = fmod(fabs(value), base);
   return remainder < EPSILON || base - remainder < EPSILON;
 }
 
 }  // namespace
 
 namespace ui {
 
 Layer::Layer(Compositor* compositor)
     : type_(LAYER_HAS_TEXTURE),
       compositor_(compositor),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       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),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  CreateWebLayer();
+#endif
 }
 
 Layer::~Layer() {
   if (parent_)
     parent_->Remove(this);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
+  if (!web_layer_.isNull())

[Ben Goodger (Google), 2011/10/16 22:39:51]

I'd actually rather see #ifdefs in this file... given that when we flip the
switch we probably won't want all these null checks.

[piman, 2011/10/19 17:53:23]

Done. My initial thought was that we could support 2 compositors with a run-time
flag, but I think it's misguided, so I reverted to #ifdefs.

+    web_layer_.removeFromParent();
 }
 
 Compositor* Layer::GetCompositor() {
   return compositor_ ? compositor_ : parent_ ? parent_->GetCompositor() : NULL;
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called once, with a valid compositor, and only
   // for the compositor's root layer.
   DCHECK(!compositor_);
   DCHECK(compositor);
   DCHECK_EQ(compositor->root_layer(), this);
   compositor_ = compositor;
 }
 
 void Layer::Add(Layer* child) {
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
+  if (!web_layer_.isNull()) {
+    DCHECK(!child->web_layer_.isNull());
+    web_layer_.addChild(child->web_layer_);
+  }
 
   RecomputeHole();
 }
 
 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 (!child->web_layer_.isNull())
+    child->web_layer_.removeFromParent();
 
   RecomputeHole();
 
   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);
+  if (!web_layer_.isNull()) {
+    DCHECK(!child->web_layer_.isNull());
+    child->web_layer_.removeFromParent();
+    web_layer_.addChild(child->web_layer_);
+  }
 }
 
 bool Layer::Contains(const Layer* other) const {
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
@@ skipping 43 matching lines @@
   bool was_drawn = IsDrawn();
   visible_ = visible;
   bool is_drawn = IsDrawn();
   if (was_drawn == is_drawn)
     return;
 
   if (!is_drawn)
     DropTextures();
   if (parent_)
     parent_->RecomputeHole();
+  if (!web_layer_.isNull()) {
+    // TODO(piman): Expose a visibility flag on WebLayer.
+    web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
+  }
 }
 
 bool Layer::IsDrawn() const {
   const Layer* layer = this;
   while (layer && layer->visible_)
     layer = layer->parent_;
   return layer == NULL;
 }
 
-bool Layer::ShouldDraw() {
+bool Layer::ShouldDraw() const {
   return type_ == LAYER_HAS_TEXTURE && GetCombinedOpacity() > 0.0f &&
       !hole_rect_.Contains(gfx::Rect(gfx::Point(0, 0), bounds_.size()));
 }
 
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   const Layer* inner = NULL;
   const Layer* outer = NULL;
@@ skipping 11 matching lines @@
 }
 
 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();
+  if (!web_layer_.isNull())
+    web_layer_.setOpaque(fills_bounds_opaquely);
 }
 
 void Layer::SetExternalTexture(ui::Texture* texture) {
   DCHECK(texture);
   layer_updated_externally_ = true;
   texture_ = texture;
 }
 
 void Layer::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
+  DCHECK(web_layer_.isNull());
   DCHECK_EQ(type_, LAYER_HAS_TEXTURE);
 
   if (!texture_.get())
     texture_ = GetCompositor()->CreateTexture();
 
   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);
-  ScheduleDraw();
+  if (web_layer_.isNull()) {
+    invalid_rect_ = invalid_rect_.Union(invalid_rect);
+    ScheduleDraw();
+  } else {
+    WebKit::WebFloatRect web_rect(invalid_rect.x(),
+        invalid_rect.y(),
+        invalid_rect.width(),
+        invalid_rect.height());
+    web_layer_.invalidateRect(web_rect);
+  }
 }
 
 void Layer::ScheduleDraw() {
-  if (GetCompositor())
-    GetCompositor()->ScheduleDraw();
+  Compositor* compositor = GetCompositor();
+  if (compositor)
+    compositor->ScheduleDraw();
 }
 
 void Layer::Draw() {
+  DCHECK(web_layer_.isNull());
   DCHECK(GetCompositor());
   if (!ShouldDraw())
     return;
 
   UpdateLayerCanvas();
 
   // Layer drew nothing, no texture was created.
   if (!texture_.get())
     return;
 
@@ skipping 22 matching lines @@
   PunchHole(gfx::Rect(gfx::Point(), bounds().size()), hole_rect_,
             &regions_to_draw);
 
   for (size_t i = 0; i < regions_to_draw.size(); ++i) {
     if (!regions_to_draw[i].IsEmpty())
       texture_->Draw(texture_draw_params, regions_to_draw[i]);
   }
 }
 
 void Layer::DrawTree() {
+  DCHECK(web_layer_.isNull());
   if (!visible_)
     return;
 
   Draw();
   for (size_t i = 0; i < children_.size(); ++i)
     children_.at(i)->DrawTree();
 }
 
+void Layer::notifyNeedsComposite() {
+  DCHECK(!web_layer_.isNull());
+  ScheduleDraw();
+}
+
+void Layer::RecomputeDrawsContent() {

[Ben Goodger (Google), 2011/10/16 22:39:51]

order in .cc should match .h

[piman, 2011/10/19 17:53:23]

Done.

+  DCHECK(!web_layer_.isNull());
+  web_layer_.setDrawsContent(ShouldDraw());
+}
+
+void Layer::paintContents(WebKit::WebCanvas* web_canvas,
+                          const WebKit::WebRect& clip) {
+  DCHECK(!web_layer_.isNull());
+  gfx::CanvasSkia canvas(web_canvas);
+  delegate_->OnPaintLayer(&canvas);
+}
+
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
   return opacity;
 }
 
 void Layer::UpdateLayerCanvas() {
+  DCHECK(web_layer_.isNull());
   // If we have no delegate, that means that whoever constructed the Layer is
   // setting its canvas directly with SetCanvas().
   if (!delegate_ || layer_updated_externally_)
     return;
   gfx::Rect local_bounds = gfx::Rect(gfx::Point(), bounds_.size());
   gfx::Rect draw_rect = texture_.get() ? invalid_rect_.Intersect(local_bounds) :
       local_bounds;
   if (draw_rect.IsEmpty()) {
     invalid_rect_ = gfx::Rect();
     return;
@@ skipping 41 matching lines @@
     candidate_hole = bounds().Intersect(candidate_hole);
 
     // Ensure we have the largest hole.
     if (candidate_hole.size().GetArea() > hole_rect_.size().GetArea())
       hole_rect_ = candidate_hole;
   }
 
   // Free up texture memory if the hole fills bounds of layer.
   if (!ShouldDraw() && !layer_updated_externally_)
     texture_ = NULL;
+
+  if (!web_layer_.isNull())
+    RecomputeDrawsContent();
 }
 
 bool Layer::IsCompletelyOpaque() const {
   return fills_bounds_opaquely() && GetCombinedOpacity() == 1.0f;
 }
 
 // static
 void Layer::PunchHole(const gfx::Rect& rect,
                       const gfx::Rect& region_to_punch_out,
                       std::vector<gfx::Rect>* sides) {
@@ skipping 23 matching lines @@
                              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() {
+  if (!web_layer_.isNull())
+    return;
   if (!layer_updated_externally_)
     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);
@@ skipping 46 matching lines @@
     SetTransformImmediately(animator_->GetTargetTransform());
   }
   animator_.reset();
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   if (parent())
     parent()->RecomputeHole();
+  if (!web_layer_.isNull()) {
+    web_layer_.setBounds(bounds.size());
+    RecomputeTransform();
+    RecomputeDrawsContent();
+  }
 }
 
 void Layer::SetTransformImmediately(const ui::Transform& transform) {
   transform_ = transform;
 
   if (parent())
     parent()->RecomputeHole();
+  if (!web_layer_.isNull())
+    RecomputeTransform();
+}
+
+void Layer::RecomputeTransform() {
+  DCHECK(!web_layer_.isNull());
+  ui::Transform transform = transform_;
+  transform.ConcatTranslate(bounds_.x(), bounds_.y());
+  web_layer_.setTransform(transform.matrix());
 }
 
 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));
     }
   }
+  if (!web_layer_.isNull()) {
+    if (visible_)
+      web_layer_.setOpacity(opacity);
+    RecomputeDrawsContent();
+  }
 }
 
 void Layer::SetBoundsFromAnimator(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
 
 void Layer::SetTransformFromAnimator(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
 void Layer::SetOpacityFromAnimator(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
+void Layer::CreateWebLayer() {
+  web_layer_ = WebKit::WebContentLayer::create(this, this);
+  web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
+  web_layer_.setOpaque(true);
+  RecomputeDrawsContent();
+}
+
 }  // namespace ui