ui: Cleanup ui::Layer

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 32 matching lines @@
 
 namespace ui {
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
-      layer_updated_externally_(false),
       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),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       cc_layer_(NULL),
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
-      layer_updated_externally_(false),
       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),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
@@ skipping 389 matching lines @@
 
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK(texture);
 
   // Hold a ref to the old |Texture| until we have updated all
   // compositor references to the texture id that it holds.
   scoped_refptr<ui::Texture> old_texture = texture_;
 
   DCHECK_EQ(type_, LAYER_TEXTURED);
   DCHECK(!solid_color_layer_.get());
-  layer_updated_externally_ = true;
   texture_ = texture;
   if (!texture_layer_.get()) {
     scoped_refptr<cc::TextureLayer> new_layer = cc::TextureLayer::Create(this);
     new_layer->SetFlipped(texture_->flipped());
     SwitchToLayer(new_layer);
     texture_layer_ = new_layer;
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetTextureMailbox(
     const cc::TextureMailbox& mailbox,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     float scale_factor) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   DCHECK(!solid_color_layer_.get());
-  layer_updated_externally_ = true;
   texture_ = NULL;
   if (!texture_layer_.get() || !texture_layer_->uses_mailbox()) {
     scoped_refptr<cc::TextureLayer> new_layer =
         cc::TextureLayer::CreateForMailbox(this);
     new_layer->SetFlipped(false);
     SwitchToLayer(new_layer);
     texture_layer_ = new_layer;
   }
   texture_layer_->SetTextureMailbox(mailbox, release_callback.Pass());
   mailbox_ = mailbox;
   mailbox_scale_factor_ = scale_factor;
   RecomputeDrawsContentAndUVRect();
 }
 
 cc::TextureMailbox Layer::GetTextureMailbox(float* scale_factor) {
   if (scale_factor)
     *scale_factor = mailbox_scale_factor_;
   return mailbox_;
 }
 
 void Layer::SetShowDelegatedContent(cc::DelegatedFrameProvider* frame_provider,
                                     gfx::Size frame_size_in_dip) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
 
   scoped_refptr<cc::DelegatedRendererLayer> new_layer =
       cc::DelegatedRendererLayer::Create(frame_provider);
   SwitchToLayer(new_layer);
   delegated_renderer_layer_ = new_layer;
-  layer_updated_externally_ = true;
 
   delegated_frame_size_in_dip_ = frame_size_in_dip;
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetShowPaintedContent() {
   if (content_layer_.get())
     return;
 
   scoped_refptr<cc::ContentLayer> new_layer = cc::ContentLayer::Create(this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
 
-  layer_updated_externally_ = false;
   mailbox_ = cc::TextureMailbox();
   texture_ = NULL;
 
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetColor(SkColor color) { GetAnimator()->SetColor(color); }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if (type_ == LAYER_SOLID_COLOR || (!delegate_ && !texture_.get()))
@@ skipping 154 matching lines @@
 bool Layer::ConvertPointFromAncestor(const Layer* ancestor,
                                      gfx::Point* point) const {
   gfx::Transform transform;
   bool result = GetTargetTransformRelativeTo(ancestor, &transform);
   gfx::Point3F p(*point);
   transform.TransformPointReverse(&p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
 
-void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
+void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
 
   base::Closure closure;
   if (delegate_)
     closure = delegate_->PrepareForLayerBoundsChange();
   bool was_move = bounds_.size() == bounds.size();
   bounds_ = bounds;
 
   RecomputeDrawsContentAndUVRect();
   RecomputePosition();
 
   if (!closure.is_null())
     closure.Run();
 
   if (was_move) {
     // Don't schedule a draw if we're invisible. We'll schedule one
     // automatically when we get visible.
     if (IsDrawn())
       ScheduleDraw();
   } else {
     // Always schedule a paint, even if we're invisible.
     SchedulePaint(gfx::Rect(bounds.size()));
   }
 }
 
-void Layer::SetTransformImmediately(const gfx::Transform& transform) {
+void Layer::SetTransformFromAnimation(const gfx::Transform& transform) {
   RecomputeCCTransformFromTransform(transform);
 }
 
-void Layer::SetOpacityImmediately(float opacity) {
+void Layer::SetOpacityFromAnimation(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
 
-void Layer::SetVisibilityImmediately(bool visible) {
+void Layer::SetVisibilityFromAnimation(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   cc_layer_->SetHideLayerAndSubtree(!visible_);
 }
 
-void Layer::SetBrightnessImmediately(float brightness) {
+void Layer::SetBrightnessFromAnimation(float brightness) {
   layer_brightness_ = brightness;
   SetLayerFilters();
 }
 
-void Layer::SetGrayscaleImmediately(float grayscale) {
+void Layer::SetGrayscaleFromAnimation(float grayscale) {
   layer_grayscale_ = grayscale;
   SetLayerFilters();
 }
 
-void Layer::SetColorImmediately(SkColor color) {
+void Layer::SetColorFromAnimation(SkColor color) {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
   solid_color_layer_->SetBackgroundColor(color);
   SetFillsBoundsOpaquely(SkColorGetA(color) == 0xFF);
 }
 
-void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
-  SetBoundsImmediately(bounds);
-}
-
-void Layer::SetTransformFromAnimation(const gfx::Transform& transform) {
-  SetTransformImmediately(transform);
-}
-
-void Layer::SetOpacityFromAnimation(float opacity) {
-  SetOpacityImmediately(opacity);
-}
-
-void Layer::SetVisibilityFromAnimation(bool visibility) {
-  SetVisibilityImmediately(visibility);
-}
-
-void Layer::SetBrightnessFromAnimation(float brightness) {
-  SetBrightnessImmediately(brightness);
-}
-
-void Layer::SetGrayscaleFromAnimation(float grayscale) {
-  SetGrayscaleImmediately(grayscale);
-}
-
-void Layer::SetColorFromAnimation(SkColor color) {
-  SetColorImmediately(color);
-}
-
 void Layer::ScheduleDrawForAnimation() {
   ScheduleDraw();
 }
 
 const gfx::Rect& Layer::GetBoundsForAnimation() const {
   return bounds();
 }
 
 gfx::Transform Layer::GetTransformForAnimation() const {
   return transform();
@@ skipping 141 matching lines @@
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::ScalePoint(
         gfx::PointF(bounds_.x(), bounds_.y()),
         device_scale_factor_));
 }
 
 }  // namespace ui