cc/blink/web_animation_impl.cc

   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 "cc/blink/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 "cc/blink/web_filter_animation_curve_impl.h"
  11 #include "cc/blink/web_float_animation_curve_impl.h"
  12 #include "cc/blink/web_scroll_offset_animation_curve_impl.h"
  13 #include "cc/blink/web_transform_animation_curve_impl.h"
  14 #include "third_party/WebKit/public/platform/WebCompositorAnimationCurve.h"
  15
  16 using cc::Animation;
  17 using cc::AnimationIdProvider;
  18
  19 using blink::WebCompositorAnimation;
  20 using blink::WebCompositorAnimationCurve;
  21
  22 namespace cc_blink {
  23
  24 WebCompositorAnimationImpl::WebCompositorAnimationImpl(
  25     const WebCompositorAnimationCurve& 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   WebCompositorAnimationCurve::AnimationCurveType curve_type = web_curve.type();
  35   scoped_ptr<cc::AnimationCurve> curve;
  36   switch (curve_type) {
  37     case WebCompositorAnimationCurve::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 WebCompositorAnimationCurve::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 WebCompositorAnimationCurve::AnimationCurveTypeFilter: {
  50       const WebFilterAnimationCurveImpl* filter_curve_impl =
  51           static_cast<const WebFilterAnimationCurveImpl*>(&web_curve);
  52       curve = filter_curve_impl->CloneToAnimationCurve();
  53       break;
  54     }
  55     case WebCompositorAnimationCurve::AnimationCurveTypeScrollOffset: {
  56       const WebScrollOffsetAnimationCurveImpl* scroll_curve_impl =
  57           static_cast<const WebScrollOffsetAnimationCurveImpl*>(&web_curve);
  58       curve = scroll_curve_impl->CloneToAnimationCurve();
  59       break;
  60     }
  61   }
  62   animation_ = Animation::Create(
  63       curve.Pass(),
  64       animation_id,
  65       group_id,
  66       static_cast<cc::Animation::TargetProperty>(target_property));
  67 }
  68
  69 WebCompositorAnimationImpl::~WebCompositorAnimationImpl() {
  70 }
  71
  72 int WebCompositorAnimationImpl::id() {
  73   return animation_->id();
  74 }
  75
  76 int WebCompositorAnimationImpl::group() {
  77   return animation_->group();
  78 }
  79
  80 blink::WebCompositorAnimation::TargetProperty
  81 WebCompositorAnimationImpl::targetProperty() const {
  82   return static_cast<WebCompositorAnimationImpl::TargetProperty>(
  83       animation_->target_property());
  84 }
  85
  86 double WebCompositorAnimationImpl::iterations() const {
  87   return animation_->iterations();
  88 }
  89
  90 void WebCompositorAnimationImpl::setIterations(double n) {
  91   animation_->set_iterations(n);
  92 }
  93
  94 double WebCompositorAnimationImpl::iterationStart() const {
  95   return animation_->iteration_start();
  96 }
  97
  98 void WebCompositorAnimationImpl::setIterationStart(double iteration_start) {
  99   animation_->set_iteration_start(iteration_start);
 100 }
 101
 102 double WebCompositorAnimationImpl::startTime() const {
 103   return (animation_->start_time() - base::TimeTicks()).InSecondsF();
 104 }
 105
 106 void WebCompositorAnimationImpl::setStartTime(double monotonic_time) {
 107   animation_->set_start_time(base::TimeTicks::FromInternalValue(
 108       monotonic_time * base::Time::kMicrosecondsPerSecond));
 109 }
 110
 111 double WebCompositorAnimationImpl::timeOffset() const {
 112   return animation_->time_offset().InSecondsF();
 113 }
 114
 115 void WebCompositorAnimationImpl::setTimeOffset(double monotonic_time) {
 116   animation_->set_time_offset(base::TimeDelta::FromSecondsD(monotonic_time));
 117 }
 118
 119 blink::WebCompositorAnimation::Direction WebCompositorAnimationImpl::direction()
 120     const {
 121   switch (animation_->direction()) {
 122     case cc::Animation::Normal:
 123       return DirectionNormal;
 124     case cc::Animation::Reverse:
 125       return DirectionReverse;
 126     case cc::Animation::Alternate:
 127       return DirectionAlternate;
 128     case cc::Animation::AlternateReverse:
 129       return DirectionAlternateReverse;
 130     default:
 131       NOTREACHED();
 132   }
 133   return DirectionNormal;
 134 }
 135
 136 void WebCompositorAnimationImpl::setDirection(Direction direction) {
 137   switch (direction) {
 138     case DirectionNormal:
 139       animation_->set_direction(cc::Animation::Normal);
 140       break;
 141     case DirectionReverse:
 142       animation_->set_direction(cc::Animation::Reverse);
 143       break;
 144     case DirectionAlternate:
 145       animation_->set_direction(cc::Animation::Alternate);
 146       break;
 147     case DirectionAlternateReverse:
 148       animation_->set_direction(cc::Animation::AlternateReverse);
 149       break;
 150   }
 151 }
 152
 153 double WebCompositorAnimationImpl::playbackRate() const {
 154   return animation_->playback_rate();
 155 }
 156
 157 void WebCompositorAnimationImpl::setPlaybackRate(double playback_rate) {
 158   animation_->set_playback_rate(playback_rate);
 159 }
 160
 161 blink::WebCompositorAnimation::FillMode WebCompositorAnimationImpl::fillMode()
 162     const {
 163   switch (animation_->fill_mode()) {
 164     case cc::Animation::FillModeNone:
 165       return FillModeNone;
 166     case cc::Animation::FillModeForwards:
 167       return FillModeForwards;
 168     case cc::Animation::FillModeBackwards:
 169       return FillModeBackwards;
 170     case cc::Animation::FillModeBoth:
 171       return FillModeBoth;
 172     default:
 173       NOTREACHED();
 174   }
 175   return FillModeNone;
 176 }
 177
 178 void WebCompositorAnimationImpl::setFillMode(FillMode fill_mode) {
 179   switch (fill_mode) {
 180     case FillModeNone:
 181       animation_->set_fill_mode(cc::Animation::FillModeNone);
 182       break;
 183     case FillModeForwards:
 184       animation_->set_fill_mode(cc::Animation::FillModeForwards);
 185       break;
 186     case FillModeBackwards:
 187       animation_->set_fill_mode(cc::Animation::FillModeBackwards);
 188       break;
 189     case FillModeBoth:
 190       animation_->set_fill_mode(cc::Animation::FillModeBoth);
 191       break;
 192   }
 193 }
 194
 195 scoped_ptr<cc::Animation> WebCompositorAnimationImpl::PassAnimation() {
 196   animation_->set_needs_synchronized_start_time(true);
 197   return animation_.Pass();
 198 }
 199
 200 }  // namespace cc_blink