Prepare ui/compositor for WebLayer type change

ui/compositor/layer.cc

 // Copyright (c) 2012 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/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 43 matching lines @@
       layer_updated_externally_(false),
       opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       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();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
@@ skipping 22 matching lines @@
   if (compositor_)
     compositor_->SetRootLayer(NULL);
   if (parent_)
     parent_->Remove(this);
   if (layer_mask_)
     SetMaskLayer(NULL);
   if (layer_mask_back_link_)
     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() {
   return GetRoot(this)->compositor_;
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called to set the compositor on the root layer,
   // or to reset it.
   DCHECK(!compositor || !compositor_);
   DCHECK(!compositor || compositor->root_layer() == this);
   DCHECK(!parent_);
   compositor_ = compositor;
   if (compositor)
     OnDeviceScaleFactorChanged(compositor->device_scale_factor());
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     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_);
 }
 
 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(WEBLAYER_IS_PURE_VIRTUAL)
+  child->web_layer_->removeFromParent();
+#else
   child->web_layer_.removeFromParent();
+#endif
 }
 
 void Layer::StackAtTop(Layer* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // Already in front.
   StackAbove(child, children_.back());
 }
 
 void Layer::StackAbove(Layer* child, Layer* other) {
   StackRelativeTo(child, other, true);
@@ skipping 47 matching lines @@
 
 gfx::Rect Layer::GetTargetBounds() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::BOUNDS)) {
     return animator_->GetTargetBounds();
   }
   return bounds_;
 }
 
 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) {
   GetAnimator()->SetOpacity(opacity);
 }
 
 void Layer::SetBackgroundBlur(int blur_radius) {
   background_blur_radius_ = blur_radius;
 
   WebKit::WebFilterOperations filters;
   if (background_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) {
   layer_saturation_ = saturation;
   SetLayerFilters();
 }
 
 void Layer::SetLayerBrightness(float brightness) {
   GetAnimator()->SetBrightness(brightness);
 }
@@ skipping 30 matching lines @@
           layer_mask->children().empty() &&
           !layer_mask->layer_mask_back_link_));
   DCHECK(!layer_mask_back_link_);
   if (layer_mask_ == layer_mask)
     return;
   // We need to de-reference the currently linked object so that no problem
   // arises if the mask layer gets deleted before this object.
   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)
     layer_mask->layer_mask_back_link_ = this;
 }
 
 void Layer::SetLayerFilters() {
   WebKit::WebFilterOperations filters;
   if (layer_saturation_) {
     filters.append(WebKit::WebFilterOperation::createSaturateFilter(
         layer_saturation_));
   }
   if (layer_grayscale_) {
     filters.append(WebKit::WebFilterOperation::createGrayscaleFilter(
         layer_grayscale_));
   }
   if (layer_inverted_)
     filters.append(WebKit::WebFilterOperation::createInvertFilter(1.0));
   // Brightness goes last, because the resulting colors neeed clamping, which
   // cause further color matrix filters to be applied separately. In this order,
   // they all can be combined in a single pass.
   if (layer_brightness_) {
     filters.append(WebKit::WebFilterOperation::createBrightnessFilter(
         layer_brightness_));
   }
 
+#if defined(WEBLAYER_IS_PURE_VIRTUAL)
+  web_layer_->setFilters(filters);
+#else
   web_layer_.setFilters(filters);
+#endif
 }
 
 float Layer::GetTargetOpacity() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::OPACITY))
     return animator_->GetTargetOpacity();
   return opacity_;
 }
 
 void Layer::SetVisible(bool visible) {
@@ skipping 33 matching lines @@
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   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();
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   layer_updated_externally_ = !!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();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 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);
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if (type_ == LAYER_SOLID_COLOR || (!delegate_ && !texture_))
     return false;
 
   damaged_region_.op(invalid_rect.x(),
                      invalid_rect.y(),
                      invalid_rect.right(),
@@ skipping 24 matching lines @@
         damaged.Inset(-1, -1);
         damaged = damaged.Intersect(gfx::Rect(bounds_.size()));
       }
 
       gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
       WebKit::WebFloatRect web_rect(
           damaged_in_pixel.x(),
           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();
   }
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendDamagedRects();
 }
 
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
@@ skipping 36 matching lines @@
     delegate_->OnPaintLayer(canvas.get());
   if (scale_content_)
     canvas->Restore();
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == 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 {
   float opacity = opacity_;
   Layer* current = this->parent_;
   while (current) {
     opacity *= current->opacity_;
     current = current->parent_;
   }
   return opacity;
@@ skipping 11 matching lines @@
   if ((above && child_i == other_i + 1) || (!above && child_i + 1 == other_i))
     return;
 
   const size_t dest_i =
       above ?
       (child_i < other_i ? other_i : other_i + 1) :
       (child_i < other_i ? other_i - 1 : other_i);
   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,
                                     gfx::Point* point) const {
   ui::Transform transform;
   bool result = GetTransformRelativeTo(ancestor, &transform);
   gfx::Point3f p(*point);
   transform.TransformPoint(p);
   *point = p.AsPoint();
   return result;
@@ skipping 51 matching lines @@
   transform_ = transform;
 
   RecomputeTransform();
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
   bool schedule_draw = (opacity != opacity_ && IsDrawn());
   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();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   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) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
 void Layer::SetGrayscaleImmediately(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
@@ skipping 44 matching lines @@
 
 float Layer::GetBrightnessForAnimation() const {
   return layer_brightness();
 }
 
 float Layer::GetGrayscaleForAnimation() const {
   return layer_grayscale();
 }
 
 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 {
+    solid_color_layer_.reset();
+    texture_layer_.reset();

[piman, 2012/08/18 00:34:18]

nit: you can get rid of those 2 as well.

[jamesr, 2012/08/18 00:35:41]

I see, I missed that this was private and just called once.  Will kill!

+    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() {
   ui::Transform scale_translate;
   scale_translate.matrix().set3x3(device_scale_factor_, 0, 0,
                                   0, device_scale_factor_, 0,
                                   0, 0, 1);
   // Start with the inverse matrix of above.
   Transform transform;
   transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
                             0, 1.0f / device_scale_factor_, 0,
                             0, 0, 1);
   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_)
       texture_size = texture_->size();
     else
       texture_size = ConvertSizeToDIP(this, texture_->size());
 
     gfx::Size size(std::min(bounds().width(), texture_size.width()),
                    std::min(bounds().height(), texture_size.height()));
     WebKit::WebFloatRect rect(
         0,
         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
   }
 }
 
 void Layer::RecomputeDebugBorderColor() {
   if (!show_debug_borders_)
     return;
   unsigned int color = 0xFF000000;
   color |= web_layer_is_accelerated_ ? 0x0000FF00 : 0x00FF0000;
   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