cc: Chromify Layer and LayerImpl classes.

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 93 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;
-  cc_layer_->removeLayerAnimationEventObserver(this);
-  cc_layer_->removeFromParent();
+  cc_layer_->RemoveLayerAnimationEventObserver(this);
+  cc_layer_->RemoveFromParent();
 }
 
 Compositor* Layer::GetCompositor() {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 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);
-  cc_layer_->addChild(child->cc_layer_);
+  cc_layer_->AddChild(child->cc_layer_);
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
   child->UpdateIsDrawn();
 }
 
 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;
-  child->cc_layer_->removeFromParent();
+  child->cc_layer_->RemoveFromParent();
 }
 
 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) {
-  cc_layer_->setMasksToBounds(masks_to_bounds);
+  cc_layer_->SetMasksToBounds(masks_to_bounds);
 }
 
 bool Layer::GetMasksToBounds() const {
-  return cc_layer_->masksToBounds();
+  return cc_layer_->masks_to_bounds();
 }
 
 void Layer::SetOpacity(float opacity) {
   GetAnimator()->SetOpacity(opacity);
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = this->opacity();
   Layer* current = this->parent_;
   while (current) {
@@ skipping 50 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;
-  cc_layer_->setMaskLayer(
+  cc_layer_->SetMaskLayer(
       layer_mask ? layer_mask->cc_layer() : NULL);
   // 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;
     layer_mask->OnDeviceScaleFactorChanged(device_scale_factor_);
   }
 }
 
 void Layer::SetBackgroundZoom(float x_offset,
@@ skipping 21 matching lines @@
   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::createSaturatingBrightnessFilter(
         layer_brightness_));
   }
 
-  cc_layer_->setFilters(filters);
+  cc_layer_->SetFilters(filters);
 }
 
 void Layer::SetLayerBackgroundFilters() {
   WebKit::WebFilterOperations filters;
   if (zoom_ != 1) {
     filters.append(WebKit::WebFilterOperation::createZoomFilter(
         WebKit::WebRect(zoom_x_offset_, zoom_y_offset_,
                         (GetTargetBounds().width() / zoom_),
                         (GetTargetBounds().height() / zoom_)),
         zoom_inset_));
   }
 
   if (background_blur_radius_) {
     filters.append(WebKit::WebFilterOperation::createBlurFilter(
         background_blur_radius_));
   }
 
-  cc_layer_->setBackgroundFilters(filters);
+  cc_layer_->SetBackgroundFilters(filters);
 }
 
 float Layer::GetTargetOpacity() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::OPACITY))
     return animator_->GetTargetOpacity();
   return opacity();
 }
 
 void Layer::SetVisible(bool visible) {
@@ skipping 11 matching lines @@
   return is_drawn_;
 }
 
 void Layer::UpdateIsDrawn() {
   bool updated_is_drawn = visible_ && (!parent_ || parent_->IsDrawn());
 
   if (updated_is_drawn == is_drawn_)
     return;
 
   is_drawn_ = updated_is_drawn;
-  cc_layer_->setIsDrawable(is_drawn_ && type_ != LAYER_NOT_DRAWN);
+  cc_layer_->SetIsDrawable(is_drawn_ && type_ != LAYER_NOT_DRAWN);
 
   for (size_t i = 0; i < children_.size(); ++i) {
     children_[i]->UpdateIsDrawn();
   }
 }
 
 bool Layer::ShouldDraw() const {
   return type_ != LAYER_NOT_DRAWN && GetCombinedOpacity() > 0.0f;
 }
 
@@ skipping 12 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;
 
-  cc_layer_->setContentsOpaque(fills_bounds_opaquely);
+  cc_layer_->SetContentsOpaque(fills_bounds_opaquely);
 }
 
 void Layer::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) {
   if (texture_layer_.get())
     texture_layer_->willModifyTexture();
   // TODO(piman): delegated_renderer_layer_ cleanup.
 
-  cc_layer_->removeAllChildren();
+  cc_layer_->RemoveAllChildren();
   if (parent_) {
     DCHECK(parent_->cc_layer_);
-    parent_->cc_layer_->replaceChild(cc_layer_, new_layer);
+    parent_->cc_layer_->ReplaceChild(cc_layer_, new_layer);
   }
-  cc_layer_->removeLayerAnimationEventObserver(this);
-  new_layer->setOpacity(cc_layer_->opacity());
+  cc_layer_->RemoveLayerAnimationEventObserver(this);
+  new_layer->SetOpacity(cc_layer_->opacity());
 
   cc_layer_= new_layer;
   content_layer_ = NULL;
   solid_color_layer_ = NULL;
   texture_layer_ = NULL;
   delegated_renderer_layer_ = NULL;
 
-  cc_layer_->addLayerAnimationEventObserver(this);
+  cc_layer_->AddLayerAnimationEventObserver(this);
   for (size_t i = 0; i < children_.size(); ++i) {
     DCHECK(children_[i]->cc_layer_);
-    cc_layer_->addChild(children_[i]->cc_layer_);
+    cc_layer_->AddChild(children_[i]->cc_layer_);
   }
-  cc_layer_->setAnchorPoint(gfx::PointF());
-  cc_layer_->setContentsOpaque(fills_bounds_opaquely_);
-  cc_layer_->setForceRenderSurface(force_render_surface_);
-  cc_layer_->setIsDrawable(IsDrawn());
+  cc_layer_->SetAnchorPoint(gfx::PointF());
+  cc_layer_->SetContentsOpaque(fills_bounds_opaquely_);
+  cc_layer_->SetForceRenderSurface(force_render_surface_);
+  cc_layer_->SetIsDrawable(IsDrawn());
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   DCHECK(!solid_color_layer_);
   bool has_texture = !!texture;
   layer_updated_externally_ = has_texture;
   texture_ = texture;
   if (!!texture_layer_ != has_texture) {
     // Switch to a different type of layer.
     if (has_texture) {
       scoped_refptr<cc::TextureLayer> new_layer =
-          cc::TextureLayer::create(this);
+          cc::TextureLayer::Create(this);
       new_layer->setFlipped(texture_->flipped());
       SwitchToLayer(new_layer);
       texture_layer_ = new_layer;
     } else {
       scoped_refptr<cc::ContentLayer> new_layer =
-          cc::ContentLayer::create(this);
+          cc::ContentLayer::Create(this);
       SwitchToLayer(new_layer);
       content_layer_ = new_layer;
     }
     RecomputeTransform();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame,
                               gfx::Size frame_size_in_dip) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   bool has_frame = frame.get() && !frame->render_pass_list.empty();
   layer_updated_externally_ = has_frame;
   delegated_frame_size_in_dip_ = frame_size_in_dip;
   if (!!delegated_renderer_layer_ != has_frame) {
     if (has_frame) {
       scoped_refptr<cc::DelegatedRendererLayer> new_layer =
           cc::DelegatedRendererLayer::Create();
       SwitchToLayer(new_layer);
       delegated_renderer_layer_ = new_layer;
     } else {
       scoped_refptr<cc::ContentLayer> new_layer =
-          cc::ContentLayer::create(this);
+          cc::ContentLayer::Create(this);
       SwitchToLayer(new_layer);
       content_layer_ = new_layer;
     }
     RecomputeTransform();
   }
   if (has_frame)
     delegated_renderer_layer_->SetFrameData(frame.Pass());
   RecomputeDrawsContentAndUVRect();
 }
 
@@ skipping 31 matching lines @@
     for (SkRegion::Iterator iter(damaged_region_);
          !iter.done(); iter.next()) {
       const SkIRect& sk_damaged = iter.rect();
       gfx::Rect damaged(
           sk_damaged.x(),
           sk_damaged.y(),
           sk_damaged.width(),
           sk_damaged.height());
 
       gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
-      cc_layer_->setNeedsDisplayRect(damaged_in_pixel);
+      cc_layer_->SetNeedsDisplayRect(damaged_in_pixel);
     }
     damaged_region_.setEmpty();
   }
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendDamagedRects();
 }
 
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
@@ skipping 45 matching lines @@
 WebKit::WebGraphicsContext3D* Layer::context() {
   DCHECK(texture_layer_);
   return texture_->HostContext3D();
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
     return;
 
   force_render_surface_ = force;
-  cc_layer_->setForceRenderSurface(force_render_surface_);
+  cc_layer_->SetForceRenderSurface(force_render_surface_);
 }
 
 void Layer::OnAnimationStarted(const cc::AnimationEvent& event) {
   if (animator_)
     animator_->OnThreadedAnimationStarted(event);
 }
 
 void Layer::StackRelativeTo(Layer* child, Layer* other, bool above) {
   DCHECK_NE(child, other);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, other->parent());
 
   const size_t child_i =
       std::find(children_.begin(), children_.end(), child) - children_.begin();
   const size_t other_i =
       std::find(children_.begin(), children_.end(), other) - children_.begin();
   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);
 
-  child->cc_layer_->removeFromParent();
-  cc_layer_->insertChild(child->cc_layer_, dest_i);
+  child->cc_layer_->RemoveFromParent();
+  cc_layer_->InsertChild(child->cc_layer_, dest_i);
 }
 
 bool Layer::ConvertPointForAncestor(const Layer* ancestor,
                                     gfx::Point* point) const {
   gfx::Transform transform;
   bool result = GetTargetTransformRelativeTo(ancestor, &transform);
   gfx::Point3F p(*point);
   transform.TransformPoint(p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
@@ skipping 51 matching lines @@
   }
 }
 
 void Layer::SetTransformImmediately(const gfx::Transform& transform) {
   transform_ = transform;
 
   RecomputeTransform();
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
-  cc_layer_->setOpacity(opacity);
+  cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   UpdateIsDrawn();
 }
 
 void Layer::SetBrightnessImmediately(float brightness) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
 void Layer::SetGrayscaleImmediately(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
 }
 
 void Layer::SetColorImmediately(SkColor color) {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
   // WebColor is equivalent to SkColor, per WebColor.h.
-  solid_color_layer_->setBackgroundColor(static_cast<WebKit::WebColor>(color));
+  solid_color_layer_->SetBackgroundColor(static_cast<WebKit::WebColor>(color));
   SetFillsBoundsOpaquely(SkColorGetA(color) == 0xFF);
 }
 
 void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
 
 void Layer::SetTransformFromAnimation(const gfx::Transform& transform) {
   SetTransformImmediately(transform);
 }
@@ skipping 44 matching lines @@
 
 float Layer::GetGrayscaleForAnimation() const {
   return layer_grayscale();
 }
 
 SkColor Layer::GetColorForAnimation() const {
   // WebColor is equivalent to SkColor, per WebColor.h.
   // The NULL check is here since this is invoked regardless of whether we have
   // been configured as LAYER_SOLID_COLOR.
   return solid_color_layer_.get() ?
-      solid_color_layer_->backgroundColor() : SK_ColorBLACK;
+      solid_color_layer_->background_color() : SK_ColorBLACK;
 }
 
 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
   DCHECK(cc_layer_);
   cc_layer_->AddAnimation(animation.Pass());
 }
 
 void Layer::RemoveThreadedAnimation(int animation_id) {
   DCHECK(cc_layer_);
   cc_layer_->RemoveAnimation(animation_id);
 }
 
 void Layer::CreateWebLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_ = cc::SolidColorLayer::Create();
     cc_layer_ = solid_color_layer_.get();
   } else {
-    content_layer_ = cc::ContentLayer::create(this);
+    content_layer_ = cc::ContentLayer::Create(this);
     cc_layer_ = content_layer_.get();
   }
-  cc_layer_->setAnchorPoint(gfx::PointF());
-  cc_layer_->setContentsOpaque(true);
-  cc_layer_->setIsDrawable(type_ != LAYER_NOT_DRAWN);
-  cc_layer_->addLayerAnimationEventObserver(this);
+  cc_layer_->SetAnchorPoint(gfx::PointF());
+  cc_layer_->SetContentsOpaque(true);
+  cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
+  cc_layer_->AddLayerAnimationEventObserver(this);
 }
 
 void Layer::RecomputeTransform() {
   gfx::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.
   gfx::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_);
   gfx::Transform translate;
   translate.Translate(bounds_.x(), bounds_.y());
   transform.ConcatTransform(translate);
   transform.ConcatTransform(scale_translate);
-  cc_layer_->setTransform(transform);
+  cc_layer_->SetTransform(transform);
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
     DCHECK(texture_);
 
     float texture_scale_factor = 1.0f / texture_->device_scale_factor();
     gfx::Size texture_size = gfx::ToFlooredSize(
         gfx::ScaleSize(texture_->size(), texture_scale_factor));
     size.ClampToMax(texture_size);
 
     gfx::PointF uv_top_left(0.f, 0.f);
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(
         ConvertSizeToPixel(this, delegated_frame_size_in_dip_));
     size.ClampToMax(delegated_frame_size_in_dip_);
   }
-  cc_layer_->setBounds(ConvertSizeToPixel(this, size));
+  cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 }  // namespace ui