Use WebKit compositor in ui::Layer

ui/gfx/compositor/layer.h

 // 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.
 
 #ifndef UI_GFX_COMPOSITOR_LAYER_H_
 #define UI_GFX_COMPOSITOR_LAYER_H_
 #pragma once
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebContentLayer.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebContentLayerClient.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebLayerClient.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/layer_animator_delegate.h"
 #include "ui/gfx/compositor/layer_delegate.h"
 
 class SkCanvas;
 
 namespace ui {
 
 class Animation;
 class Compositor;
 class Texture;
 
 // Layer manages a texture, transform and a set of child Layers. Any View that
 // has enabled layers ends up creating a Layer to manage the texture.
 // A Layer can also be created without a texture, in which case it renders
 // nothing and is simply used as a node in a hierarchy of layers.
 //
 // NOTE: unlike Views, each Layer does *not* own its children views. If you
 // delete a Layer and it has children, the parent of each child layer is set to
 // NULL, but the children are not deleted.
-class COMPOSITOR_EXPORT Layer : public LayerAnimatorDelegate {
+class COMPOSITOR_EXPORT Layer : public LayerAnimatorDelegate,
+                                public WebKit::WebLayerClient,
+                                public WebKit::WebContentLayerClient {
  public:
   enum LayerType {
     LAYER_HAS_NO_TEXTURE = 0,
     LAYER_HAS_TEXTURE = 1
   };
 
   // |compositor| can be NULL, and will be set later when the Layer is added to
   // a Compositor.
   explicit Layer(Compositor* compositor);
   Layer(Compositor* compositor, LayerType type);
@@ skipping 56 matching lines @@
   // Sets the visibility of the Layer. A Layer may be visible but not
   // drawn. This happens if any ancestor of a Layer is not visible.
   void SetVisible(bool visible);
 
   // Returns true if this Layer is drawn. A Layer is drawn only if all ancestors
   // are visible.
   bool IsDrawn() const;
 
   // Returns true if this layer can have a texture (has_texture_ is true)
   // and is not completely obscured by a child.
-  bool ShouldDraw();
+  bool ShouldDraw() const;
 
   // Converts a point from the coordinates of |source| to the coordinates of
   // |target|. Necessarily, |source| and |target| must inhabit the same Layer
   // tree.
   static void ConvertPointToLayer(const Layer* source,
                                   const Layer* target,
                                   gfx::Point* point);
 
   // See description in View for details
   void SetFillsBoundsOpaquely(bool fills_bounds_opaquely);
@@ skipping 27 matching lines @@
   void Draw();
 
   // Draws a tree of Layers, by calling Draw() on each in the hierarchy starting
   // with the receiver.
   void DrawTree();
 
   // Sometimes the Layer is being updated by something other than SetCanvas
   // (e.g. the GPU process on TOUCH_UI).
   bool layer_updated_externally() const { return layer_updated_externally_; }
 
+  // WebLayerClient
+  virtual void notifyNeedsComposite();
+
+  // WebContentLayerClient
+  virtual void paintContents(WebKit::WebCanvas*, const WebKit::WebRect& clip);
+
+  WebKit::WebContentLayer web_layer() { return web_layer_; }
+
  private:
   // TODO(vollick): Eventually, if a non-leaf node has an opacity of less than
   // 1.0, we'll render to a separate texture, and then apply the alpha.
   // Currently, we multiply our opacity by all our ancestor's opacities and
   // use the combined result, but this is only temporary.
   float GetCombinedOpacity() const;
 
   // Called during the Draw() pass to freshen the Layer's contents from the
   // delegate.
   void UpdateLayerCanvas();
 
   // A hole in a layer is an area in the layer that does not get drawn
   // because this area is covered up with another layer which is known to be
   // opaque.
   // This method computes the dimension of the hole (if there is one)
   // based on whether one of its child nodes is always opaque.
   // Note: For simplicity's sake, currently a hole is only created if the child
   // view has no transform with respect to its parent.
   void RecomputeHole();
 
+  void RecomputeTransform();
+  void RecomputeDrawsContent();
+
   // Returns true if the layer paints every pixel (fills_bounds_opaquely)
   // and the alpha of the layer is 1.0f.
   bool IsCompletelyOpaque() const;
 
   // Determines the regions that don't intersect |rect| and places the
   // result in |sides|.
   //
   //  rect_____________________________
   //  |xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|
   //  |xxxxxxxxxxxxx top xxxxxxxxxxxxxx|
@@ skipping 34 matching lines @@
   // update the values immediately.
   void SetBoundsImmediately(const gfx::Rect& bounds);
   void SetTransformImmediately(const ui::Transform& transform);
   void SetOpacityImmediately(float opacity);
 
   // LayerAnimatorDelegate overrides:
   virtual void SetBoundsFromAnimator(const gfx::Rect& bounds) OVERRIDE;
   virtual void SetTransformFromAnimator(const Transform& transform) OVERRIDE;
   virtual void SetOpacityFromAnimator(float opacity) OVERRIDE;
 
+  void CreateWebLayer();
+
   const LayerType type_;
 
   Compositor* compositor_;
 
   scoped_refptr<ui::Texture> texture_;
 
   Layer* parent_;
 
   std::vector<Layer*> children_;
 
@@ skipping 12 matching lines @@
 
   // If true the layer is always up to date.
   bool layer_updated_externally_;
 
   float opacity_;
 
   LayerDelegate* delegate_;
 
   scoped_ptr<LayerAnimator> animator_;
 
+  WebKit::WebContentLayer web_layer_;
+
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_GFX_COMPOSITOR_LAYER_H_