cc: Chromify the Animation and LayerAnimationController classes

ui/compositor/layer_animator.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_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/animation_id_provider.h"
@@ skipping 301 matching lines @@
   // Remove the observer from all sequences as well.
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     (*queue_iter)->RemoveObserver(observer);
   }
 }
 
 void LayerAnimator::OnThreadedAnimationStarted(
     const cc::AnimationEvent& event) {
   LayerAnimationElement::AnimatableProperty property =
-    LayerAnimationElement::ToAnimatableProperty(event.targetProperty);
+    LayerAnimationElement::ToAnimatableProperty(event.target_property);
 
   RunningAnimation* running = GetRunningAnimation(property);
   if (!running)
     return;
   DCHECK(running->is_sequence_alive());
 
-  if (running->sequence()->animation_group_id() != event.groupId)
+  if (running->sequence()->animation_group_id() != event.group_id)
     return;
 
   running->sequence()->OnThreadedAnimationStarted(event);
   if (!running->sequence()->waiting_for_group_start())
     return;
 
   base::TimeTicks start_time = base::TimeTicks::FromInternalValue(
-      event.monotonicTime * base::Time::kMicrosecondsPerSecond);
+      event.monotonic_time * base::Time::kMicrosecondsPerSecond);
 
   running->sequence()->set_waiting_for_group_start(false);
 
   // The call to GetRunningAnimation made above already purged deleted
   // animations, so we are guaranteed that all the animations we iterate
   // over now are alive.
   for (RunningAnimations::iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
     // Ensure that each sequence is only Started once, regardless of the
     // number of sequences in the group that have threaded first elements.
-    if (((*iter).sequence()->animation_group_id() == event.groupId) &&
+    if (((*iter).sequence()->animation_group_id() == event.group_id) &&
         !(*iter).sequence()->IsFirstElementThreaded() &&
         (*iter).sequence()->waiting_for_group_start()) {
       (*iter).sequence()->set_start_time(start_time);
       (*iter).sequence()->set_waiting_for_group_start(false);
       (*iter).sequence()->Start(delegate());
     }
   }
 }
 
 // LayerAnimator protected -----------------------------------------------------
@@ skipping 491 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui