cc: Move filters to the effect tree

cc/animation/element_animations.cc

 // Copyright 2015 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/element_animations.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 132 matching lines @@
   RemoveAnimationsCompletedOnMainThread(element_animations_impl.get());
 
   PushPropertiesToImplThread(element_animations_impl.get());
   element_animations_impl->UpdateActivation(NORMAL_ACTIVATION);
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::AddAnimation(std::unique_ptr<Animation> animation) {
   DCHECK(!animation->is_impl_only() ||
          animation->target_property() == TargetProperty::SCROLL_OFFSET);
-  bool added_transform_animation =
-      animation->target_property() == TargetProperty::TRANSFORM;
-  bool added_opacity_animation =
-      animation->target_property() == TargetProperty::OPACITY;
+  TargetProperty::Type target_property = animation->target_property();
   animations_.push_back(std::move(animation));
   needs_to_start_animations_ = true;
   UpdateActivation(NORMAL_ACTIVATION);
-  if (added_transform_animation)
-    UpdateClientAnimationState(TargetProperty::TRANSFORM);
-  if (added_opacity_animation)
-    UpdateClientAnimationState(TargetProperty::OPACITY);
+  switch (target_property) {
+    case TargetProperty::TRANSFORM:
+    case TargetProperty::OPACITY:
+    case TargetProperty::FILTER:
+      UpdateClientAnimationState(target_property);
+      break;
+    default:
+      break;
+  }
 }
 
 void ElementAnimations::Animate(base::TimeTicks monotonic_time) {
   DCHECK(!monotonic_time.is_null());
   if (!has_element_in_active_list() && !has_element_in_pending_list())
     return;
 
   if (needs_to_start_animations_)
     StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
   UpdateClientAnimationState(TargetProperty::OPACITY);
   UpdateClientAnimationState(TargetProperty::TRANSFORM);
+  UpdateClientAnimationState(TargetProperty::FILTER);
 }
 
 void ElementAnimations::UpdateState(bool start_ready_animations,
                                     AnimationEvents* events) {
   if (!has_element_in_active_list())
     return;
 
   // Animate hasn't been called, this happens if an element 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);
   }
 
   UpdateActivation(NORMAL_ACTIVATION);
 }
 
 void ElementAnimations::ActivateAnimations() {
   bool changed_transform_animation = false;
   bool changed_opacity_animation = false;
+  bool changed_filter_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->affects_active_elements() !=
         animations_[i]->affects_pending_elements()) {
       if (animations_[i]->target_property() == TargetProperty::TRANSFORM)
         changed_transform_animation = true;
       else if (animations_[i]->target_property() == TargetProperty::OPACITY)
         changed_opacity_animation = true;
+      else if (animations_[i]->target_property() == TargetProperty::FILTER)
+        changed_filter_animation = true;
     }
     animations_[i]->set_affects_active_elements(
         animations_[i]->affects_pending_elements());
   }
   auto affects_no_elements = [](const std::unique_ptr<Animation>& animation) {
     return !animation->affects_active_elements() &&
            !animation->affects_pending_elements();
   };
   animations_.erase(std::remove_if(animations_.begin(), animations_.end(),
                                    affects_no_elements),
                     animations_.end());
   scroll_offset_animation_was_interrupted_ = false;
   UpdateActivation(NORMAL_ACTIVATION);
   if (changed_transform_animation)
     UpdateClientAnimationState(TargetProperty::TRANSFORM);
   if (changed_opacity_animation)
     UpdateClientAnimationState(TargetProperty::OPACITY);
+  if (changed_filter_animation)
+    UpdateClientAnimationState(TargetProperty::FILTER);
 }
 
 void ElementAnimations::NotifyAnimationStarted(const AnimationEvent& event) {
   if (event.is_impl_only) {
     NotifyPlayersAnimationStarted(event.monotonic_time, event.target_property,
                                   event.group_id);
     return;
   }
 
   for (size_t i = 0; i < animations_.size(); ++i) {
@@ skipping 35 matching lines @@
   DCHECK(event.target_property == TargetProperty::SCROLL_OFFSET);
   if (!players_list_->empty()) {
     std::unique_ptr<AnimationCurve> animation_curve = event.curve->Clone();
     NotifyPlayersAnimationTakeover(event.monotonic_time, event.target_property,
                                    event.animation_start_time,
                                    std::move(animation_curve));
   }
 }
 
 void ElementAnimations::NotifyAnimationAborted(const AnimationEvent& event) {
-  bool aborted_transform_animation = false;
-  bool aborted_opacity_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property) {
       animations_[i]->SetRunState(Animation::ABORTED, event.monotonic_time);
       animations_[i]->set_received_finished_event(true);
       NotifyPlayersAnimationAborted(event.monotonic_time, event.target_property,
                                     event.group_id);
-      if (event.target_property == TargetProperty::TRANSFORM)
-        aborted_transform_animation = true;
-      else if (event.target_property == TargetProperty::OPACITY)
-        aborted_opacity_animation = true;
       break;
     }
   }
-  if (aborted_transform_animation)
-    UpdateClientAnimationState(TargetProperty::TRANSFORM);
-  if (aborted_opacity_animation)
-    UpdateClientAnimationState(TargetProperty::OPACITY);
+  switch (event.target_property) {
+    case TargetProperty::TRANSFORM:
+    case TargetProperty::OPACITY:
+    case TargetProperty::FILTER:
+      UpdateClientAnimationState(event.target_property);
+      break;
+    default:
+      break;
+  }
 }
 
 void ElementAnimations::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
   bool notify_active_elements = true;
   bool notify_pending_elements = true;
   switch (event.target_property) {
     case TargetProperty::OPACITY:
       NotifyClientOpacityAnimated(event.opacity, notify_active_elements,
                                   notify_pending_elements);
@@ skipping 238 matching lines @@
     return (animation->run_state() == Animation::WAITING_FOR_DELETION);
   } else {
     return !main_thread_element_animations->GetAnimationById(animation->id());
   }
 }
 
 void ElementAnimations::RemoveAnimationsCompletedOnMainThread(
     ElementAnimations* element_animations_impl) const {
   bool removed_transform_animation = false;
   bool removed_opacity_animation = false;
+  bool removed_filter_animation = false;
   // Animations removed on the main thread should no longer affect pending
   // elements, and should stop affecting active elements after the next call
   // to ActivateAnimations. If already WAITING_FOR_DELETION, they can be removed
   // immediately.
   auto& animations = element_animations_impl->animations_;
   for (const auto& animation : animations) {
     if (IsCompleted(animation.get(), this)) {
       animation->set_affects_pending_elements(false);
       if (animation->target_property() == TargetProperty::TRANSFORM)
         removed_transform_animation = true;
       else if (animation->target_property() == TargetProperty::OPACITY)
         removed_opacity_animation = true;
+      else if (animation->target_property() == TargetProperty::FILTER)
+        removed_filter_animation = true;
     }
   }
   auto affects_active_only_and_is_waiting_for_deletion =
       [](const std::unique_ptr<Animation>& animation) {
         return animation->run_state() == Animation::WAITING_FOR_DELETION &&
                !animation->affects_pending_elements();
       };
   animations.erase(
       std::remove_if(animations.begin(), animations.end(),
                      affects_active_only_and_is_waiting_for_deletion),
       animations.end());
 
-  if (removed_transform_animation)
+  if (removed_transform_animation) {
     element_animations_impl->UpdateClientAnimationState(
         TargetProperty::TRANSFORM);
-  if (removed_opacity_animation)
+  }
+  if (removed_opacity_animation) {
     element_animations_impl->UpdateClientAnimationState(
         TargetProperty::OPACITY);
+  }
+  if (removed_filter_animation) {
+    element_animations_impl->UpdateClientAnimationState(TargetProperty::FILTER);
+  }
 }
 
 void ElementAnimations::PushPropertiesToImplThread(
     ElementAnimations* element_animations_impl) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     Animation* current_impl =
         element_animations_impl->GetAnimationById(animations_[i]->id());
     if (current_impl)
       animations_[i]->PushPropertiesTo(current_impl);
   }
@@ skipping 123 matching lines @@
         else
           events->events_.push_back(started_event);
       }
     }
   }
 }
 
 void ElementAnimations::MarkFinishedAnimations(base::TimeTicks monotonic_time) {
   bool finished_transform_animation = false;
   bool finished_opacity_animation = false;
+  bool finished_filter_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (!animations_[i]->is_finished() &&
         animations_[i]->IsFinishedAt(monotonic_time)) {
       animations_[i]->SetRunState(Animation::FINISHED, monotonic_time);
       if (animations_[i]->target_property() == TargetProperty::TRANSFORM)
         finished_transform_animation = true;
       else if (animations_[i]->target_property() == TargetProperty::OPACITY)
         finished_opacity_animation = true;
+      else if (animations_[i]->target_property() == TargetProperty::FILTER)
+        finished_filter_animation = true;
     }
   }
   if (finished_transform_animation)
     UpdateClientAnimationState(TargetProperty::TRANSFORM);
   if (finished_opacity_animation)
     UpdateClientAnimationState(TargetProperty::OPACITY);
+  if (finished_filter_animation)
+    UpdateClientAnimationState(TargetProperty::FILTER);
 }
 
 void ElementAnimations::MarkAnimationsForDeletion(
     base::TimeTicks monotonic_time,
     AnimationEvents* events) {
   bool marked_animations_for_deletions = false;
   std::vector<size_t> animations_with_same_group_id;
 
   animations_with_same_group_id.reserve(animations_.size());
   // Non-aborted animations are marked for deletion after a corresponding
@@ skipping 112 matching lines @@
     }
   }
   if (marked_animations_for_deletions)
     NotifyClientAnimationWaitingForDeletion();
 }
 
 void ElementAnimations::MarkAbortedAnimationsForDeletion(
     ElementAnimations* element_animations_impl) const {
   bool aborted_transform_animation = false;
   bool aborted_opacity_animation = false;
+  bool aborted_filter_animation = false;
   auto& animations_impl = element_animations_impl->animations_;
   for (const auto& animation_impl : animations_impl) {
     // If the animation has been aborted on the main thread, mark it for
     // deletion.
     if (Animation* animation = GetAnimationById(animation_impl->id())) {
       if (animation->run_state() == Animation::ABORTED) {
         animation_impl->SetRunState(Animation::WAITING_FOR_DELETION,
                                     element_animations_impl->last_tick_time_);
         animation->SetRunState(Animation::WAITING_FOR_DELETION,
                                last_tick_time_);
         if (animation_impl->target_property() == TargetProperty::TRANSFORM)
           aborted_transform_animation = true;
         else if (animation_impl->target_property() == TargetProperty::OPACITY)
           aborted_opacity_animation = true;
+        else if (animation_impl->target_property() == TargetProperty::FILTER)
+          aborted_filter_animation = true;
       }
     }
   }
 
-  if (aborted_transform_animation)
+  if (aborted_transform_animation) {
     element_animations_impl->UpdateClientAnimationState(
         TargetProperty::TRANSFORM);
-  if (aborted_opacity_animation)
+  }
+  if (aborted_opacity_animation) {
     element_animations_impl->UpdateClientAnimationState(
         TargetProperty::OPACITY);
+  }
+  if (aborted_filter_animation) {
+    element_animations_impl->UpdateClientAnimationState(TargetProperty::FILTER);
+  }
 }
 
 void ElementAnimations::PurgeAnimationsMarkedForDeletion() {
   animations_.erase(
       std::remove_if(animations_.begin(), animations_.end(),
                      [](const std::unique_ptr<Animation>& animation) {
                        return animation->run_state() ==
                               Animation::WAITING_FOR_DELETION;
                      }),
       animations_.end());
@@ skipping 133 matching lines @@
     bool notify_elements_about_potential_animation,
     bool notify_elements_about_running_animation) {
   struct PropertyAnimationState* animation_state = nullptr;
   switch (property) {
     case TargetProperty::OPACITY:
       animation_state = &opacity_animation_state_;
       break;
     case TargetProperty::TRANSFORM:
       animation_state = &transform_animation_state_;
       break;
+    case TargetProperty::FILTER:
+      animation_state = &filter_animation_state_;
+      break;
     default:
       NOTREACHED();
       break;
   }
 
   bool notify_elements_about_potential_and_running_animation =
       notify_elements_about_potential_animation &&
       notify_elements_about_running_animation;
   bool active = list_type == ElementListType::ACTIVE;
   if (notify_elements_about_potential_and_running_animation) {
@@ skipping 24 matching lines @@
 void ElementAnimations::UpdateClientAnimationState(
     TargetProperty::Type property) {
   struct PropertyAnimationState* animation_state = nullptr;
   switch (property) {
     case TargetProperty::OPACITY:
       animation_state = &opacity_animation_state_;
       break;
     case TargetProperty::TRANSFORM:
       animation_state = &transform_animation_state_;
       break;
+    case TargetProperty::FILTER:
+      animation_state = &filter_animation_state_;
+      break;
     default:
       NOTREACHED();
       break;
   }
   bool was_currently_running_animation_for_active_elements =
       animation_state->currently_running_for_active_elements;
   bool was_currently_running_animation_for_pending_elements =
       animation_state->currently_running_for_pending_elements;
   bool was_potentially_animating_for_active_elements =
       animation_state->potentially_animating_for_active_elements;
@@ skipping 98 matching lines @@
       animations_[i]->SetRunState(Animation::PAUSED,
                                   time_offset + animations_[i]->start_time() +
                                       animations_[i]->time_offset());
     }
   }
 }
 
 void ElementAnimations::RemoveAnimation(int animation_id) {
   bool removed_transform_animation = false;
   bool removed_opacity_animation = false;
+  bool removed_filter_animation = false;
   // Since we want to use the animations that we're going to remove, we need to
   // use a stable_parition here instead of remove_if. Remove_if leaves the
   // removed items in an unspecified state.
   auto animations_to_remove = std::stable_partition(
       animations_.begin(), animations_.end(),
       [animation_id](const std::unique_ptr<Animation>& animation) {
         return animation->id() != animation_id;
       });
   for (auto it = animations_to_remove; it != animations_.end(); ++it) {
     if ((*it)->target_property() == TargetProperty::SCROLL_OFFSET) {
       scroll_offset_animation_was_interrupted_ = true;
     } else if ((*it)->target_property() == TargetProperty::TRANSFORM &&
                !(*it)->is_finished()) {
       removed_transform_animation = true;
     } else if ((*it)->target_property() == TargetProperty::OPACITY &&
                !(*it)->is_finished()) {
       removed_opacity_animation = true;
+    } else if ((*it)->target_property() == TargetProperty::FILTER &&
+               !(*it)->is_finished()) {
+      removed_filter_animation = true;
     }
   }
 
   animations_.erase(animations_to_remove, animations_.end());
   UpdateActivation(NORMAL_ACTIVATION);
   if (removed_transform_animation)
     UpdateClientAnimationState(TargetProperty::TRANSFORM);
   if (removed_opacity_animation)
     UpdateClientAnimationState(TargetProperty::OPACITY);
+  if (removed_filter_animation)
+    UpdateClientAnimationState(TargetProperty::FILTER);
 }
 
 void ElementAnimations::AbortAnimation(int animation_id) {
-  bool aborted_transform_animation = false;
-  bool aborted_opacity_animation = false;
   if (Animation* animation = GetAnimationById(animation_id)) {
     if (!animation->is_finished()) {
       animation->SetRunState(Animation::ABORTED, last_tick_time_);
-      if (animation->target_property() == TargetProperty::TRANSFORM)
-        aborted_transform_animation = true;
-      else if (animation->target_property() == TargetProperty::OPACITY)
-        aborted_opacity_animation = true;
+      switch (animation->target_property()) {
+        case TargetProperty::TRANSFORM:
+        case TargetProperty::OPACITY:
+        case TargetProperty::FILTER:
+          UpdateClientAnimationState(animation->target_property());
+          break;
+        default:
+          break;
+      }
     }
   }
-  if (aborted_transform_animation)
-    UpdateClientAnimationState(TargetProperty::TRANSFORM);
-  if (aborted_opacity_animation)
-    UpdateClientAnimationState(TargetProperty::OPACITY);
 }
 
 void ElementAnimations::AbortAnimations(TargetProperty::Type target_property,
                                         bool needs_completion) {
   if (needs_completion)
     DCHECK(target_property == TargetProperty::SCROLL_OFFSET);
 
-  bool aborted_transform_animation = false;
-  bool aborted_opacity_animation = false;
+  bool aborted_animation = false;
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->target_property() == target_property &&
         !animations_[i]->is_finished()) {
       // Currently only impl-only scroll offset animations can be completed on
       // the main thread.
       if (needs_completion && animations_[i]->is_impl_only()) {
         animations_[i]->SetRunState(Animation::ABORTED_BUT_NEEDS_COMPLETION,
                                     last_tick_time_);
       } else {
         animations_[i]->SetRunState(Animation::ABORTED, last_tick_time_);
       }
-      if (target_property == TargetProperty::TRANSFORM)
-        aborted_transform_animation = true;
-      else if (target_property == TargetProperty::OPACITY)
-        aborted_opacity_animation = true;
+      aborted_animation = true;
     }
   }
-  if (aborted_transform_animation)
-    UpdateClientAnimationState(TargetProperty::TRANSFORM);
-  if (aborted_opacity_animation)
-    UpdateClientAnimationState(TargetProperty::OPACITY);
+  if (aborted_animation) {
+    switch (target_property) {
+      case TargetProperty::TRANSFORM:
+      case TargetProperty::OPACITY:
+      case TargetProperty::FILTER:
+        UpdateClientAnimationState(target_property);
+        break;
+      default:
+        break;
+    }
+  }
 }
 
 Animation* ElementAnimations::GetAnimation(
     TargetProperty::Type target_property) const {
   for (size_t i = 0; i < animations_.size(); ++i) {
     size_t index = animations_.size() - i - 1;
     if (animations_[index]->target_property() == target_property)
       return animations_[index].get();
   }
   return nullptr;
@@ skipping 64 matching lines @@
             ->mutator_host_client()
             ->ElementOpacityIsAnimatingChanged(element_id(), list_type,
                                                change_type, is_animating);
         break;
       case TargetProperty::TRANSFORM:
         animation_host()
             ->mutator_host_client()
             ->ElementTransformIsAnimatingChanged(element_id(), list_type,
                                                  change_type, is_animating);
         break;
+      case TargetProperty::FILTER:
+        animation_host()
+            ->mutator_host_client()
+            ->ElementFilterIsAnimatingChanged(element_id(), list_type,
+                                              change_type, is_animating);
+        break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
 void ElementAnimations::NotifyPlayersAnimationStarted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
@@ skipping 47 matching lines @@
   if (animation_host()) {
     DCHECK(animation_host()->mutator_host_client());
     return animation_host()->mutator_host_client()->GetScrollOffsetForAnimation(
         element_id());
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc