Prepare ui/compositor for WebLayer type change

This is chromium-side preparation for https://bugs.webkit.org/show_bug.cgi?id=94229.
After that lands and rolls, I'll delete the #else branches.

BUG=none


Review URL: https://chromiumcodereview.appspot.com/10832355

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@152228 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 159 insertions, 3 deletions

diff --git a/ui/compositor/layer.cc b/ui/compositor/layer.cc
index d6b2257..94caf4b 100644
--- a/ui/compositor/layer.cc
+++ b/ui/compositor/layer.cc
@@ -61,6 +61,9 @@ Layer::Layer()
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       delegate_(NULL),
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      web_layer_(NULL),
+#endif
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
@@ -103,7 +106,11 @@ Layer::~Layer() {
     layer_mask_back_link_->SetMaskLayer(NULL);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->removeFromParent();
+#else
   web_layer_.removeFromParent();
+#endif
 }
 
 Compositor* Layer::GetCompositor() {
@@ -127,7 +134,11 @@ void Layer::Add(Layer* child) {
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->addChild(child->web_layer_);
+#else
   web_layer_.addChild(child->web_layer_);
+#endif
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
 }
 
@@ -137,7 +148,11 @@ void Layer::Remove(Layer* child) {
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  child->web_layer_->removeFromParent();
+#else
   child->web_layer_.removeFromParent();
+#endif
 }
 
 void Layer::StackAtTop(Layer* child) {
@@ -205,11 +220,19 @@ gfx::Rect Layer::GetTargetBounds() const {
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setMasksToBounds(masks_to_bounds);
+#else
   web_layer_.setMasksToBounds(masks_to_bounds);
+#endif
 }
 
 bool Layer::GetMasksToBounds() const {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  return web_layer_->masksToBounds();
+#else
   return web_layer_.masksToBounds();
+#endif
 }
 
 void Layer::SetOpacity(float opacity) {
@@ -224,7 +247,11 @@ void Layer::SetBackgroundBlur(int blur_radius) {
     filters.append(WebKit::WebFilterOperation::createBlurFilter(
         background_blur_radius_));
   }
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setBackgroundFilters(filters);
+#else
   web_layer_.setBackgroundFilters(filters);
+#endif
 }
 
 void Layer::SetLayerSaturation(float saturation) {
@@ -275,8 +302,13 @@ void Layer::SetMaskLayer(Layer* layer_mask) {
   if (layer_mask_)
     layer_mask_->layer_mask_back_link_ = NULL;
   layer_mask_ = layer_mask;
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setMaskLayer(
+      layer_mask ? layer_mask->web_layer() : NULL);
+#else
   web_layer_.setMaskLayer(
       layer_mask ? layer_mask->web_layer() : WebKit::WebLayer());
+#endif
   // We need to reference the linked object so that it can properly break the
   // link to us when it gets deleted.
   if (layer_mask)
@@ -303,7 +335,11 @@ void Layer::SetLayerFilters() {
         layer_brightness_));
   }
 
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setFilters(filters);
+#else
   web_layer_.setFilters(filters);
+#endif
 }
 
 float Layer::GetTargetOpacity() const {
@@ -357,7 +393,11 @@ void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setOpaque(fills_bounds_opaquely);
+#else
   web_layer_.setOpaque(fills_bounds_opaquely);
+#endif
   RecomputeDebugBorderColor();
 }
 
@@ -367,31 +407,73 @@ void Layer::SetExternalTexture(Texture* texture) {
   texture_ = texture;
   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_->removeAllChildren();
+    content_layer_.reset();
+    solid_color_layer_.reset();
+    WebKit::WebLayer* new_layer = NULL;
+#else
     web_layer_.removeAllChildren();
     WebKit::WebLayer new_layer;
+#endif
     if (layer_updated_externally_) {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      texture_layer_.reset(WebKit::WebExternalTextureLayer::create());
+      texture_layer_->setFlipped(texture_->flipped());
+      new_layer = texture_layer_->layer();
+#else
       WebKit::WebExternalTextureLayer texture_layer =
           WebKit::WebExternalTextureLayer::create();
       texture_layer.setFlipped(texture_->flipped());
       new_layer = texture_layer;
+#endif
     } else {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      texture_layer_.reset();
+      solid_color_layer_.reset();
+      content_layer_.reset(WebKit::WebContentLayer::create(this));
+      new_layer = content_layer_->layer();
+#else
       new_layer = WebKit::WebContentLayer::create(this);
+#endif
     }
     if (parent_) {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      DCHECK(parent_->web_layer_);
+      parent_->web_layer_->replaceChild(web_layer_, new_layer);
+#else
       DCHECK(!parent_->web_layer_.isNull());
       parent_->web_layer_.replaceChild(web_layer_, new_layer);
+#endif
     }
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_= new_layer;
+#else
     web_layer_ = new_layer;
+#endif
     web_layer_is_accelerated_ = layer_updated_externally_;
     for (size_t i = 0; i < children_.size(); ++i) {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      DCHECK(children_[i]->web_layer_);
+      web_layer_->addChild(children_[i]->web_layer_);
+#else
       DCHECK(!children_[i]->web_layer_.isNull());
       web_layer_.addChild(children_[i]->web_layer_);
+#endif
     }
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_->setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
+    web_layer_->setOpaque(fills_bounds_opaquely_);
+    web_layer_->setOpacity(visible_ ? opacity_ : 0.f);
+    web_layer_->setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
+    web_layer_->setForceRenderSurface(force_render_surface_);
+#else
     web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
     web_layer_.setOpaque(fills_bounds_opaquely_);
     web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
     web_layer_.setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
     web_layer_.setForceRenderSurface(force_render_surface_);
+#endif
     RecomputeTransform();
     RecomputeDebugBorderColor();
   }
@@ -401,8 +483,12 @@ void Layer::SetExternalTexture(Texture* texture) {
 void Layer::SetColor(SkColor color) {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
   // WebColor is equivalent to SkColor, per WebColor.h.
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  solid_color_layer_->setBackgroundColor(static_cast<WebKit::WebColor>(color));
+#else
   web_layer_.to<WebKit::WebSolidColorLayer>().setBackgroundColor(
       static_cast<WebKit::WebColor>(color));
+#endif
   SetFillsBoundsOpaquely(SkColorGetA(color) == 0xFF);
 }
 
@@ -447,11 +533,15 @@ void Layer::SendDamagedRects() {
           damaged_in_pixel.y(),
           damaged_in_pixel.width(),
           damaged_in_pixel.height());
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      web_layer_->invalidateRect(web_rect);
+#else
       if (!web_layer_is_accelerated_)
         web_layer_.to<WebKit::WebContentLayer>().invalidateRect(web_rect);
       else
         web_layer_.to<WebKit::WebExternalTextureLayer>().invalidateRect(
             web_rect);
+#endif
     }
     damaged_region_.setEmpty();
   }
@@ -508,7 +598,11 @@ void Layer::SetForceRenderSurface(bool force) {
     return;
 
   force_render_surface_ = force;
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setForceRenderSurface(force_render_surface_);
+#else
   web_layer_.setForceRenderSurface(force_render_surface_);
+#endif
 }
 
 float Layer::GetCombinedOpacity() const {
@@ -540,8 +634,13 @@ void Layer::StackRelativeTo(Layer* child, Layer* other, bool above) {
   children_.erase(children_.begin() + child_i);
   children_.insert(children_.begin() + dest_i, child);
 
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  child->web_layer_->removeFromParent();
+  web_layer_->insertChild(child->web_layer_, dest_i);
+#else
   child->web_layer_.removeFromParent();
   web_layer_.insertChild(child->web_layer_, dest_i);
+#endif
 }
 
 bool Layer::ConvertPointForAncestor(const Layer* ancestor,
@@ -613,7 +712,11 @@ void Layer::SetOpacityImmediately(float opacity) {
   opacity_ = opacity;
 
   if (visible_)
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_->setOpacity(opacity);
+#else
     web_layer_.setOpacity(opacity);
+#endif
   RecomputeDebugBorderColor();
   if (schedule_draw)
     ScheduleDraw();
@@ -625,7 +728,11 @@ void Layer::SetVisibilityImmediately(bool visible) {
 
   visible_ = visible;
   // TODO(piman): Expose a visibility flag on WebLayer.
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setOpacity(visible_ ? opacity_ : 0.f);
+#else
   web_layer_.setOpacity(visible_ ? opacity_ : 0.f);
+#endif
 }
 
 void Layer::SetBrightnessImmediately(float brightness) {
@@ -690,16 +797,32 @@ float Layer::GetGrayscaleForAnimation() const {
 }
 
 void Layer::CreateWebLayer() {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  if (type_ == LAYER_SOLID_COLOR) {
+    solid_color_layer_.reset(WebKit::WebSolidColorLayer::create());
+    web_layer_ = solid_color_layer_->layer();
+  } else {
+    content_layer_.reset(WebKit::WebContentLayer::create(this));
+    web_layer_ = content_layer_->layer();
+  }
+#else
   if (type_ == LAYER_SOLID_COLOR)
     web_layer_ = WebKit::WebSolidColorLayer::create();
   else
     web_layer_ = WebKit::WebContentLayer::create(this);
-  web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
-  web_layer_.setOpaque(true);
+#endif
   web_layer_is_accelerated_ = false;
   show_debug_borders_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUIShowLayerBorders);
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
+  web_layer_->setOpaque(true);
+  web_layer_->setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
+#else
+  web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
+  web_layer_.setOpaque(true);
   web_layer_.setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
+#endif
 }
 
 void Layer::RecomputeTransform() {
@@ -715,22 +838,43 @@ void Layer::RecomputeTransform() {
   transform.ConcatTransform(transform_);
   transform.ConcatTranslate(bounds_.x(), bounds_.y());
   transform.ConcatTransform(scale_translate);
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setTransform(transform.matrix());
+#else
   web_layer_.setTransform(transform.matrix());
+#endif
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  DCHECK(web_layer_);
+#else
   DCHECK(!web_layer_.isNull());
+#endif
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
-    if (type_ != LAYER_SOLID_COLOR)
+    if (type_ != LAYER_SOLID_COLOR) {
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+      web_layer_->setDrawsContent(should_draw);
+#else
       web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
+#endif
+    }
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_->setBounds(ConvertSizeToPixel(this, bounds_.size()));
+#else
     web_layer_.setBounds(ConvertSizeToPixel(this, bounds_.size()));
+#endif
   } else {
     DCHECK(texture_);
     unsigned int texture_id = texture_->texture_id();
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    texture_layer_->setTextureId(should_draw ? texture_id : 0);
+#else
     WebKit::WebExternalTextureLayer texture_layer =
         web_layer_.to<WebKit::WebExternalTextureLayer>();
     texture_layer.setTextureId(should_draw ? texture_id : 0);
+#endif
 
     gfx::Size texture_size;
     if (scale_content_)
@@ -745,10 +889,18 @@ void Layer::RecomputeDrawsContentAndUVRect() {
         0,
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    texture_layer_->setUVRect(rect);
+#else
     texture_layer.setUVRect(rect);
+#endif
 
     gfx::Size size_in_pixel = ConvertSizeToPixel(this, size);
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+    web_layer_->setBounds(size_in_pixel);
+#else
     web_layer_.setBounds(size_in_pixel);
+#endif
   }
 }
 
@@ -760,7 +912,11 @@ void Layer::RecomputeDebugBorderColor() {
   bool opaque = fills_bounds_opaquely_ && (GetCombinedOpacity() == 1.f);
   if (!opaque)
     color |= 0xFF;
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setDebugBorderColor(color);
+#else
   web_layer_.setDebugBorderColor(color);
+#endif
 }
 
 }  // namespace ui