Update from https://crrev.com/304121

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 <vector>
 
 #include "cc/animation/animation.h"
@@ skipping 130 matching lines @@
     return;
 
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* animation = animations_[i];
     if (!animation->is_impl_only())
       continue;
 
     if (!animation->InEffect(monotonic_time))
       continue;
 
-    double trimmed = animation->TrimTimeToCurrentIteration(monotonic_time);
+    double trimmed =
+        animation->TrimTimeToCurrentIteration(monotonic_time).InSecondsF();
     switch (animation->target_property()) {
       case Animation::Opacity: {
         AnimationEvent event(AnimationEvent::PropertyUpdate,
                              id_,
                              animation->group(),
                              Animation::Opacity,
                              monotonic_time);
         const FloatAnimationCurve* float_animation_curve =
             animation->curve()->ToFloatAnimationCurve();
         event.opacity = float_animation_curve->GetValue(trimmed);
@@ skipping 43 matching lines @@
         NOTREACHED();
     }
   }
 }
 
 void LayerAnimationController::UpdateState(bool start_ready_animations,
                                            AnimationEventsVector* events) {
   if (!HasActiveValueObserver())
     return;
 
-  DCHECK(last_tick_time_ != base::TimeTicks());
+  // Animate hasn't been called, this happens if an observer has been added
+  // between the Commit and Draw phases.
+  if (last_tick_time_ == base::TimeTicks())
+    return;
+
   if (start_ready_animations)
     PromoteStartedAnimations(last_tick_time_, events);
 
   MarkFinishedAnimations(last_tick_time_);
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (needs_to_start_animations_ && start_ready_animations) {
     StartAnimations(last_tick_time_);
     PromoteStartedAnimations(last_tick_time_, events);
   }
@@ skipping 623 matching lines @@
 }
 
 void LayerAnimationController::TickAnimations(base::TimeTicks monotonic_time) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting ||
         animations_[i]->run_state() == Animation::Running ||
         animations_[i]->run_state() == Animation::Paused) {
       if (!animations_[i]->InEffect(monotonic_time))
         continue;
 
-      double trimmed =
-          animations_[i]->TrimTimeToCurrentIteration(monotonic_time);
+      double trimmed = animations_[i]
+                           ->TrimTimeToCurrentIteration(monotonic_time)
+                           .InSecondsF();
 
       switch (animations_[i]->target_property()) {
         case Animation::Transform: {
           const TransformAnimationCurve* transform_animation_curve =
               animations_[i]->curve()->ToTransformAnimationCurve();
           const gfx::Transform transform =
               transform_animation_curve->GetValue(trimmed);
           NotifyObserversTransformAnimated(
               transform,
               animations_[i]->affects_active_observers(),
@@ skipping 158 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != nullptr)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc