cc: Chromify the Animation and LayerAnimationController classes

cc/layer.cc

 // Copyright 2010 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 "cc/layer.h"
 
 #include "cc/animation.h"
 #include "cc/animation_events.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
@@ skipping 43 matching lines @@
     , m_automaticallyComputeRasterScale(false)
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
 
-    m_layerAnimationController = LayerAnimationController::create(m_layerId);
-    m_layerAnimationController->addObserver(this);
+    m_layerAnimationController = LayerAnimationController::Create(m_layerId);
+    m_layerAnimationController->AddObserver(this);
     addLayerAnimationEventObserver(m_layerAnimationController.get());
 }
 
 Layer::~Layer()
 {
     // Our parent should be holding a reference to us so there should be no
     // way for us to be destroyed while we still have a parent.
     DCHECK(!parent());
 
-    m_layerAnimationController->removeObserver(this);
+    m_layerAnimationController->RemoveObserver(this);
 
     // Remove the parent reference from all children and dependents.
     removeAllChildren();
     if (m_maskLayer) {
         DCHECK_EQ(this, m_maskLayer->parent());
         m_maskLayer->removeFromParent();
     }
     if (m_replicaLayer) {
         DCHECK_EQ(this, m_replicaLayer->parent());
         m_replicaLayer->removeFromParent();
     }
 }
 
 void Layer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (m_layerTreeHost == host)
         return;
 
     m_layerTreeHost = host;
 
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->setLayerTreeHost(host);
 
     if (m_maskLayer)
         m_maskLayer->setLayerTreeHost(host);
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(host);
 
-    m_layerAnimationController->setAnimationRegistrar(host ? host->animationRegistrar() : 0);
+    m_layerAnimationController->SetAnimationRegistrar(host ? host->animationRegistrar() : 0);
 
-    if (host && m_layerAnimationController->hasAnyAnimation())
+    if (host && m_layerAnimationController->has_any_animation())
         host->setNeedsCommit();
     if (host && (!m_filters.isEmpty() || !m_backgroundFilters.isEmpty() || m_filter))
         m_layerTreeHost->setNeedsFilterContext();
 
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_ignoreSetNeedsCommit)
         return;
@@ skipping 311 matching lines @@
     setNeedsCommit();
 }
 
 float Layer::opacity() const
 {
     return m_opacity;
 }
 
 bool Layer::opacityIsAnimating() const
 {
-    return m_layerAnimationController->isAnimatingProperty(Animation::Opacity);
+    return m_layerAnimationController->IsAnimatingProperty(Animation::Opacity);
 }
 
 void Layer::setContentsOpaque(bool opaque)
 {
     if (m_contentsOpaque == opaque)
         return;
     m_contentsOpaque = opaque;
     setNeedsCommit();
 }
 
@@ skipping 21 matching lines @@
     setNeedsCommit();
 }
 
 const gfx::Transform& Layer::transform() const
 {
     return m_transform;
 }
 
 bool Layer::transformIsAnimating() const
 {
-    return m_layerAnimationController->isAnimatingProperty(Animation::Transform);
+    return m_layerAnimationController->IsAnimatingProperty(Animation::Transform);
 }
 
 void Layer::setScrollOffset(gfx::Vector2d scrollOffset)
 {
     if (m_scrollOffset == scrollOffset)
         return;
     m_scrollOffset = scrollOffset;
     if (m_layerScrollClient)
         m_layerScrollClient->didScroll();
     setNeedsCommit();
@@ skipping 183 matching lines @@
             DCHECK(layer->sentScrollDelta().IsZero());
             layer->setScrollDelta(active_twin->scrollDelta() - active_twin->sentScrollDelta());
         }
     } else {
         layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
         layer->setSentScrollDelta(gfx::Vector2d());
     }
 
     layer->setStackingOrderChanged(m_stackingOrderChanged);
 
-    m_layerAnimationController->pushAnimationUpdatesTo(layer->layerAnimationController());
+    m_layerAnimationController->PushAnimationUpdatesTo(layer->layerAnimationController());
 
     // Reset any state that should be cleared for the next update.
     m_stackingOrderChanged = false;
     m_updateRect = gfx::RectF();
 }
 
 scoped_ptr<LayerImpl> Layer::createLayerImpl(LayerTreeImpl* treeImpl)
 {
     return LayerImpl::create(treeImpl, m_layerId);
 }
@@ skipping 86 matching lines @@
     // also being run on the impl thread, there is no need to request a commit to push
     // this value over, so set this value directly rather than calling setTransform.
     m_transform = transform;
 }
 
 bool Layer::IsActive() const
 {
     return true;
 }
 
-bool Layer::addAnimation(scoped_ptr <Animation> animation)
+bool Layer::AddAnimation(scoped_ptr <Animation> animation)
 {
-    if (!m_layerAnimationController->animationRegistrar())
+    if (!m_layerAnimationController->animation_registrar())
         return false;
 
-    m_layerAnimationController->addAnimation(animation.Pass());
+    m_layerAnimationController->AddAnimation(animation.Pass());
     setNeedsCommit();
     return true;
 }
 
-void Layer::pauseAnimation(int animationId, double timeOffset)
+void Layer::PauseAnimation(int animationId, double timeOffset)
 {
-    m_layerAnimationController->pauseAnimation(animationId, timeOffset);
+    m_layerAnimationController->PauseAnimation(animationId, timeOffset);
     setNeedsCommit();
 }
 
-void Layer::removeAnimation(int animationId)
+void Layer::RemoveAnimation(int animationId)
 {
-    m_layerAnimationController->removeAnimation(animationId);
+    m_layerAnimationController->RemoveAnimation(animationId);
     setNeedsCommit();
 }
 
 void Layer::suspendAnimations(double monotonicTime)
 {
-    m_layerAnimationController->suspendAnimations(monotonicTime);
+    m_layerAnimationController->SuspendAnimations(monotonicTime);
     setNeedsCommit();
 }
 
 void Layer::resumeAnimations(double monotonicTime)
 {
-    m_layerAnimationController->resumeAnimations(monotonicTime);
+    m_layerAnimationController->ResumeAnimations(monotonicTime);
     setNeedsCommit();
 }
 
 void Layer::setLayerAnimationController(scoped_refptr<LayerAnimationController> layerAnimationController)
 {
     removeLayerAnimationEventObserver(m_layerAnimationController.get());
-    m_layerAnimationController->removeObserver(this);
+    m_layerAnimationController->RemoveObserver(this);
     m_layerAnimationController = layerAnimationController;
-    m_layerAnimationController->setForceSync();
-    m_layerAnimationController->addObserver(this);
+    m_layerAnimationController->set_force_sync();
+    m_layerAnimationController->AddObserver(this);
     addLayerAnimationEventObserver(m_layerAnimationController.get());
     setNeedsCommit();
 }
 
 scoped_refptr<LayerAnimationController> Layer::releaseLayerAnimationController()
 {
-    m_layerAnimationController->removeObserver(this);
+    m_layerAnimationController->RemoveObserver(this);
     scoped_refptr<LayerAnimationController> toReturn = m_layerAnimationController;
-    m_layerAnimationController = LayerAnimationController::create(id());
-    m_layerAnimationController->addObserver(this);
-    m_layerAnimationController->setAnimationRegistrar(toReturn->animationRegistrar());
+    m_layerAnimationController = LayerAnimationController::Create(id());
+    m_layerAnimationController->AddObserver(this);
+    m_layerAnimationController->SetAnimationRegistrar(toReturn->animation_registrar());
     return toReturn;
 }
 
 bool Layer::hasActiveAnimation() const
 {
-    return m_layerAnimationController->hasActiveAnimation();
+    return m_layerAnimationController->HasActiveAnimation();
 }
 
 void Layer::notifyAnimationStarted(const AnimationEvent& event, double wallClockTime)
 {
     FOR_EACH_OBSERVER(LayerAnimationEventObserver, m_layerAnimationObservers,
                       OnAnimationStarted(event));
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationStarted(wallClockTime);
 }
 
 void Layer::notifyAnimationFinished(double wallClockTime)
 {
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationFinished(wallClockTime);
 }
 
 void Layer::notifyAnimationPropertyUpdate(const AnimationEvent& event)
 {
-    if (event.targetProperty == Animation::Opacity)
+    if (event.target_property == Animation::Opacity)
         setOpacity(event.opacity);
     else
         setTransform(event.transform);
 }
 
 void Layer::addLayerAnimationEventObserver(LayerAnimationEventObserver* animationObserver)
 {
     if (!m_layerAnimationObservers.HasObserver(animationObserver))
         m_layerAnimationObservers.AddObserver(animationObserver);
 }
@@ skipping 14 matching lines @@
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }  // namespace cc