Fix cpplint errors in cc/(animation|input|layers|trees|test)/

cc/animation/layer_animation_controller.cc

 // Copyright 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 "cc/animation/layer_animation_controller.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 25 matching lines @@
                                               double time_offset) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->id() == animation_id) {
       active_animations_[i]->SetRunState(
           Animation::Paused, time_offset + active_animations_[i]->start_time());
     }
   }
 }
 
 struct HasAnimationId {
-  HasAnimationId(int id) : id_(id) {}
+  explicit HasAnimationId(int id) : id_(id) {}
   bool operator()(Animation* animation) const {
     return animation->id() == id_;
   }
 
  private:
   int id_;
 };
 
 void LayerAnimationController::RemoveAnimation(int animation_id) {
   ScopedPtrVector<Animation>& animations = active_animations_;
@@ skipping 96 matching lines @@
     if (animation->target_property() == Animation::Opacity) {
       AnimationEvent event(AnimationEvent::PropertyUpdate,
                            id_,
                            animation->group(),
                            Animation::Opacity,
                            monotonic_time);
       event.opacity = animation->curve()->ToFloatAnimationCurve()->GetValue(
           monotonic_time);
 
       events->push_back(event);
-    }
-    else if (animation->target_property() == Animation::Transform) {
+    } else if (animation->target_property() == Animation::Transform) {
       AnimationEvent event(AnimationEvent::PropertyUpdate,
                            id_,
                            animation->group(),
                            Animation::Transform,
                            monotonic_time);
       event.transform =
           animation->curve()->ToTransformAnimationCurve()->GetValue(
               monotonic_time);
       events->push_back(event);
     }
@@ skipping 123 matching lines @@
         Animation::WaitingForTargetAvailability;
     double start_time = 0;
     scoped_ptr<Animation> to_add(active_animations_[i]->CloneAndInitialize(
         Animation::ControllingInstance, initial_run_state, start_time));
     DCHECK(!to_add->needs_synchronized_start_time());
     controller_impl->AddAnimation(to_add.Pass());
   }
 }
 
 struct IsCompleted {
-  IsCompleted(const LayerAnimationController& main_thread_controller)
+  explicit IsCompleted(const LayerAnimationController& main_thread_controller)
       : main_thread_controller_(main_thread_controller) {}
   bool operator()(Animation* animation) const {
     if (animation->is_impl_only())
       return false;
     return !main_thread_controller_.GetAnimation(animation->group(),
                                                  animation->target_property());
   }
 
  private:
   const LayerAnimationController& main_thread_controller_;
@@ skipping 238 matching lines @@
       // start time from the impl thread and can start ticking.
       if (active_animations_[i]->needs_synchronized_start_time())
         trimmed = 0;
 
       // A just-started animation assumes its initial value.
       if (active_animations_[i]->run_state() == Animation::Starting &&
           !active_animations_[i]->has_set_start_time())
         trimmed = 0;
 
       switch (active_animations_[i]->target_property()) {
-
         case Animation::Transform: {
           const TransformAnimationCurve* transform_animation_curve =
               active_animations_[i]->curve()->ToTransformAnimationCurve();
           const gfx::Transform transform =
               transform_animation_curve->GetValue(trimmed);
           NotifyObserversTransformAnimated(transform);
           break;
         }
 
         case Animation::Opacity: {
@@ skipping 41 matching lines @@
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc