Use WebKit compositor in ui::Layer

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"
+#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 defined(USE_WEBKIT_COMPOSITOR)
+  web_layer_.removeFromParent();
+#endif
 }
 
 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 defined(USE_WEBKIT_COMPOSITOR)
+  web_layer_.addChild(child->web_layer_);
+#endif
 
   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 defined(USE_WEBKIT_COMPOSITOR)
+  child->web_layer_.removeFromParent();
+#endif
 
   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 defined(USE_WEBKIT_COMPOSITOR)
+  child->web_layer_.removeFromParent();
+  web_layer_.addChild(child->web_layer_);
+#endif
 }
 
 bool Layer::Contains(const Layer* other) const {
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
@@ skipping 49 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 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_;
   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 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;
 }
 
 void Layer::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  NOTREACHED();
+#else
   DCHECK_EQ(type_, LAYER_HAS_TEXTURE);
 
   if (!texture_.get())
     texture_ = GetCompositor()->CreateTexture();
 
   texture_->SetCanvas(canvas, origin, bounds_.size());
   invalid_rect_ = gfx::Rect();
+#endif
 }
 
 void Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  WebKit::WebFloatRect web_rect(invalid_rect.x(),
+      invalid_rect.y(),
+      invalid_rect.width(),
+      invalid_rect.height());
+  web_layer_.invalidateRect(web_rect);
+#else
   invalid_rect_ = invalid_rect_.Union(invalid_rect);
   ScheduleDraw();
+#endif
 }
 
 void Layer::ScheduleDraw() {
-  if (GetCompositor())
-    GetCompositor()->ScheduleDraw();
+  Compositor* compositor = GetCompositor();
+  if (compositor)
+    compositor->ScheduleDraw();
 }
 
 void Layer::Draw() {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  NOTREACHED();
+#else
   DCHECK(GetCompositor());
   if (!ShouldDraw())
     return;
 
   UpdateLayerCanvas();
 
   // Layer drew nothing, no texture was created.
   if (!texture_.get())
     return;
 
@@ skipping 19 matching lines @@
   texture_draw_params.has_valid_alpha_channel = has_valid_alpha_channel();
 
   std::vector<gfx::Rect> regions_to_draw;
   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]);
   }
+#endif
 }
 
 void Layer::DrawTree() {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  NOTREACHED();
+#else
   if (!visible_)
     return;
 
   Draw();
   for (size_t i = 0; i < children_.size(); ++i)
     children_.at(i)->DrawTree();
+#endif
+}
+
+void Layer::notifyNeedsComposite() {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  ScheduleDraw();
+#else
+  NOTREACHED();
+#endif
+}
+
+void Layer::paintContents(WebKit::WebCanvas* web_canvas,
+                          const WebKit::WebRect& clip) {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  gfx::CanvasSkia canvas(web_canvas);
+  delegate_->OnPaintLayer(&canvas);
+#else
+  NOTREACHED();
+#endif
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
   return opacity;
 }
 
 void Layer::UpdateLayerCanvas() {
+#if defined(USE_WEBKIT_COMPOSITOR)
+  NOTREACHED();
+#else
   // 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;
   }
   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)
     return;
 
   // Reset to default.
   hole_rect_ = gfx::Rect();
 
   // Find the largest hole
@@ skipping 25 matching lines @@
     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;
   }
 
   // Free up texture memory if the hole fills bounds of layer.
   if (!ShouldDraw() && !layer_updated_externally_)
     texture_ = NULL;
+
+#if defined(USE_WEBKIT_COMPOSITOR)
+  RecomputeDrawsContent();
+#endif
 }
 
 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 89 matching lines @@
     SetTransformImmediately(animator_->GetTargetTransform());
   }
   animator_.reset();
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   if (parent())
     parent()->RecomputeHole();
+#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();
+#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));
     }
   }
+#if defined(USE_WEBKIT_COMPOSITOR)
+  if (visible_)
+    web_layer_.setOpacity(opacity);
+  RecomputeDrawsContent();
+#endif
 }
 
 void Layer::SetBoundsFromAnimator(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
 
 void Layer::SetTransformFromAnimator(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
 void Layer::SetOpacityFromAnimator(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
+#if defined(USE_WEBKIT_COMPOSITOR)
+void Layer::CreateWebLayer() {
+  web_layer_ = WebKit::WebContentLayer::create(this, this);
+  web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
+  web_layer_.setOpaque(true);
+  RecomputeDrawsContent();
+}
+
+void Layer::RecomputeTransform() {
+  ui::Transform transform = transform_;
+  transform.ConcatTranslate(bounds_.x(), bounds_.y());
+  web_layer_.setTransform(transform.matrix());
+}
+
+void Layer::RecomputeDrawsContent() {
+  web_layer_.setDrawsContent(ShouldDraw());
+}
+#endif
+
 }  // namespace ui