Home | History | Annotate | Download | only in compositor_bindings 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/compositor_bindings/web_animation_impl.h"
      6 
      7 #include "cc/animation/animation.h"
      8 #include "cc/animation/animation_curve.h"
      9 #include "cc/animation/animation_id_provider.h"
     10 #include "content/renderer/compositor_bindings/web_filter_animation_curve_impl.h"
     11 #include "content/renderer/compositor_bindings/web_float_animation_curve_impl.h"
     12 #include "content/renderer/compositor_bindings/web_scroll_offset_animation_curve_impl.h"
     13 #include "content/renderer/compositor_bindings/web_transform_animation_curve_impl.h"
     14 #include "third_party/WebKit/public/platform/WebAnimation.h"
     15 #include "third_party/WebKit/public/platform/WebAnimationCurve.h"
     16 
     17 using cc::Animation;
     18 using cc::AnimationIdProvider;
     19 
     20 using blink::WebAnimation;
     21 using blink::WebAnimationCurve;
     22 
     23 namespace content {
     24 
     25 WebAnimationImpl::WebAnimationImpl(const WebAnimationCurve& web_curve,
     26                                    TargetProperty target_property,
     27                                    int animation_id,
     28                                    int group_id) {
     29   if (!animation_id)
     30     animation_id = AnimationIdProvider::NextAnimationId();
     31   if (!group_id)
     32     group_id = AnimationIdProvider::NextGroupId();
     33 
     34   WebAnimationCurve::AnimationCurveType curve_type = web_curve.type();
     35   scoped_ptr<cc::AnimationCurve> curve;
     36   switch (curve_type) {
     37     case WebAnimationCurve::AnimationCurveTypeFloat: {
     38       const WebFloatAnimationCurveImpl* float_curve_impl =
     39           static_cast<const WebFloatAnimationCurveImpl*>(&web_curve);
     40       curve = float_curve_impl->CloneToAnimationCurve();
     41       break;
     42     }
     43     case WebAnimationCurve::AnimationCurveTypeTransform: {
     44       const WebTransformAnimationCurveImpl* transform_curve_impl =
     45           static_cast<const WebTransformAnimationCurveImpl*>(&web_curve);
     46       curve = transform_curve_impl->CloneToAnimationCurve();
     47       break;
     48     }
     49     case WebAnimationCurve::AnimationCurveTypeFilter: {
     50       const WebFilterAnimationCurveImpl* filter_curve_impl =
     51           static_cast<const WebFilterAnimationCurveImpl*>(&web_curve);
     52       curve = filter_curve_impl->CloneToAnimationCurve();
     53       break;
     54     }
     55 #if WEB_SCROLL_OFFSET_ANIMATION_CURVE_IS_DEFINED
     56     case WebAnimationCurve::AnimationCurveTypeScrollOffset: {
     57       const WebScrollOffsetAnimationCurveImpl* scroll_curve_impl =
     58           static_cast<const WebScrollOffsetAnimationCurveImpl*>(&web_curve);
     59       curve = scroll_curve_impl->CloneToAnimationCurve();
     60       break;
     61     }
     62 #endif
     63   }
     64   animation_ = Animation::Create(
     65       curve.Pass(),
     66       animation_id,
     67       group_id,
     68       static_cast<cc::Animation::TargetProperty>(target_property));
     69 }
     70 
     71 WebAnimationImpl::~WebAnimationImpl() {
     72 }
     73 
     74 int WebAnimationImpl::id() {
     75   return animation_->id();
     76 }
     77 
     78 blink::WebAnimation::TargetProperty WebAnimationImpl::targetProperty() const {
     79   return static_cast<WebAnimationImpl::TargetProperty>(
     80       animation_->target_property());
     81 }
     82 
     83 int WebAnimationImpl::iterations() const {
     84   return animation_->iterations();
     85 }
     86 
     87 void WebAnimationImpl::setIterations(int n) {
     88   animation_->set_iterations(n);
     89 }
     90 
     91 double WebAnimationImpl::startTime() const {
     92   return (animation_->start_time() - base::TimeTicks()).InSecondsF();
     93 }
     94 
     95 void WebAnimationImpl::setStartTime(double monotonic_time) {
     96   animation_->set_start_time(base::TimeTicks::FromInternalValue(
     97       monotonic_time * base::Time::kMicrosecondsPerSecond));
     98 }
     99 
    100 double WebAnimationImpl::timeOffset() const {
    101   return animation_->time_offset().InSecondsF();
    102 }
    103 
    104 void WebAnimationImpl::setTimeOffset(double monotonic_time) {
    105   animation_->set_time_offset(base::TimeDelta::FromSecondsD(monotonic_time));
    106 }
    107 
    108 #if WEB_ANIMATION_SUPPORTS_FULL_DIRECTION
    109 blink::WebAnimation::Direction WebAnimationImpl::direction() const {
    110   switch (animation_->direction()) {
    111     case cc::Animation::Normal:
    112       return DirectionNormal;
    113     case cc::Animation::Reverse:
    114       return DirectionReverse;
    115     case cc::Animation::Alternate:
    116       return DirectionAlternate;
    117     case cc::Animation::AlternateReverse:
    118       return DirectionAlternateReverse;
    119     default:
    120       NOTREACHED();
    121   }
    122   return DirectionNormal;
    123 }
    124 
    125 void WebAnimationImpl::setDirection(Direction direction) {
    126   switch (direction) {
    127     case DirectionNormal:
    128       animation_->set_direction(cc::Animation::Normal);
    129       break;
    130     case DirectionReverse:
    131       animation_->set_direction(cc::Animation::Reverse);
    132       break;
    133     case DirectionAlternate:
    134       animation_->set_direction(cc::Animation::Alternate);
    135       break;
    136     case DirectionAlternateReverse:
    137       animation_->set_direction(cc::Animation::AlternateReverse);
    138       break;
    139   }
    140 }
    141 #else
    142 bool WebAnimationImpl::alternatesDirection() const {
    143   return animation_->direction() == cc::Animation::Alternate;
    144 }
    145 
    146 void WebAnimationImpl::setAlternatesDirection(bool alternates) {
    147   if (alternates)
    148     animation_->set_direction(cc::Animation::Alternate);
    149   else
    150     animation_->set_direction(cc::Animation::Normal);
    151 }
    152 #endif
    153 
    154 scoped_ptr<cc::Animation> WebAnimationImpl::PassAnimation() {
    155   animation_->set_needs_synchronized_start_time(true);
    156   return animation_.Pass();
    157 }
    158 
    159 }  // namespace content
    160 
    161