layer_animation_element.cc 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948
  1. // Copyright (c) 2012 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. #include "ui/compositor/layer_animation_element.h"
  5. #include <utility>
  6. #include "base/compiler_specific.h"
  7. #include "base/strings/stringprintf.h"
  8. #include "cc/animation/animation_id_provider.h"
  9. #include "cc/animation/keyframe_model.h"
  10. #include "ui/compositor/float_animation_curve_adapter.h"
  11. #include "ui/compositor/layer.h"
  12. #include "ui/compositor/layer_animation_delegate.h"
  13. #include "ui/compositor/layer_animator.h"
  14. #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  15. #include "ui/compositor/transform_animation_curve_adapter.h"
  16. #include "ui/gfx/animation/tween.h"
  17. #include "ui/gfx/interpolated_transform.h"
  18. namespace ui {
  19. namespace {
  20. // Pause -----------------------------------------------------------------------
  21. class Pause : public LayerAnimationElement {
  22. public:
  23. Pause(AnimatableProperties properties, base::TimeDelta duration)
  24. : LayerAnimationElement(properties, duration) {
  25. }
  26. Pause(const Pause&) = delete;
  27. Pause& operator=(const Pause&) = delete;
  28. ~Pause() override {}
  29. private:
  30. std::string DebugName() const override { return "Pause"; }
  31. void OnStart(LayerAnimationDelegate* delegate) override {}
  32. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  33. return false;
  34. }
  35. void OnGetTarget(TargetValue* target) const override {}
  36. void OnAbort(LayerAnimationDelegate* delegate) override {}
  37. };
  38. // InterpolatedTransformTransition ---------------------------------------------
  39. class InterpolatedTransformTransition : public LayerAnimationElement {
  40. public:
  41. InterpolatedTransformTransition(
  42. std::unique_ptr<InterpolatedTransform> interpolated_transform,
  43. base::TimeDelta duration)
  44. : LayerAnimationElement(TRANSFORM, duration),
  45. interpolated_transform_(std::move(interpolated_transform)) {}
  46. InterpolatedTransformTransition(const InterpolatedTransformTransition&) =
  47. delete;
  48. InterpolatedTransformTransition& operator=(
  49. const InterpolatedTransformTransition&) = delete;
  50. ~InterpolatedTransformTransition() override {}
  51. protected:
  52. std::string DebugName() const override {
  53. return "InterpolatedTransformTransition";
  54. }
  55. void OnStart(LayerAnimationDelegate* delegate) override {}
  56. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  57. delegate->SetTransformFromAnimation(
  58. interpolated_transform_->Interpolate(static_cast<float>(t)),
  59. PropertyChangeReason::FROM_ANIMATION);
  60. return true;
  61. }
  62. void OnGetTarget(TargetValue* target) const override {
  63. target->transform = interpolated_transform_->Interpolate(1.0f);
  64. }
  65. void OnAbort(LayerAnimationDelegate* delegate) override {}
  66. private:
  67. std::unique_ptr<InterpolatedTransform> interpolated_transform_;
  68. };
  69. // BoundsTransition ------------------------------------------------------------
  70. class BoundsTransition : public LayerAnimationElement {
  71. public:
  72. BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
  73. : LayerAnimationElement(BOUNDS, duration),
  74. target_(target) {
  75. }
  76. BoundsTransition(const BoundsTransition&) = delete;
  77. BoundsTransition& operator=(const BoundsTransition&) = delete;
  78. ~BoundsTransition() override {}
  79. protected:
  80. std::string DebugName() const override { return "BoundsTransition"; }
  81. void OnStart(LayerAnimationDelegate* delegate) override {
  82. start_ = delegate->GetBoundsForAnimation();
  83. }
  84. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  85. delegate->SetBoundsFromAnimation(
  86. gfx::Tween::RectValueBetween(t, start_, target_),
  87. PropertyChangeReason::FROM_ANIMATION);
  88. return true;
  89. }
  90. void OnGetTarget(TargetValue* target) const override {
  91. target->bounds = target_;
  92. }
  93. void OnAbort(LayerAnimationDelegate* delegate) override {}
  94. private:
  95. gfx::Rect start_;
  96. const gfx::Rect target_;
  97. };
  98. // VisibilityTransition --------------------------------------------------------
  99. class VisibilityTransition : public LayerAnimationElement {
  100. public:
  101. VisibilityTransition(bool target, base::TimeDelta duration)
  102. : LayerAnimationElement(VISIBILITY, duration),
  103. start_(false),
  104. target_(target) {
  105. }
  106. VisibilityTransition(const VisibilityTransition&) = delete;
  107. VisibilityTransition& operator=(const VisibilityTransition&) = delete;
  108. ~VisibilityTransition() override {}
  109. protected:
  110. std::string DebugName() const override { return "VisibilityTransition"; }
  111. void OnStart(LayerAnimationDelegate* delegate) override {
  112. start_ = delegate->GetVisibilityForAnimation();
  113. }
  114. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  115. delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_,
  116. PropertyChangeReason::FROM_ANIMATION);
  117. return t == 1.0;
  118. }
  119. void OnGetTarget(TargetValue* target) const override {
  120. target->visibility = target_;
  121. }
  122. void OnAbort(LayerAnimationDelegate* delegate) override {}
  123. private:
  124. bool start_;
  125. const bool target_;
  126. };
  127. // BrightnessTransition --------------------------------------------------------
  128. class BrightnessTransition : public LayerAnimationElement {
  129. public:
  130. BrightnessTransition(float target, base::TimeDelta duration)
  131. : LayerAnimationElement(BRIGHTNESS, duration),
  132. start_(0.0f),
  133. target_(target) {
  134. }
  135. BrightnessTransition(const BrightnessTransition&) = delete;
  136. BrightnessTransition& operator=(const BrightnessTransition&) = delete;
  137. ~BrightnessTransition() override {}
  138. protected:
  139. std::string DebugName() const override { return "BrightnessTransition"; }
  140. void OnStart(LayerAnimationDelegate* delegate) override {
  141. start_ = delegate->GetBrightnessForAnimation();
  142. }
  143. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  144. delegate->SetBrightnessFromAnimation(
  145. gfx::Tween::FloatValueBetween(t, start_, target_),
  146. PropertyChangeReason::FROM_ANIMATION);
  147. return true;
  148. }
  149. void OnGetTarget(TargetValue* target) const override {
  150. target->brightness = target_;
  151. }
  152. void OnAbort(LayerAnimationDelegate* delegate) override {}
  153. private:
  154. float start_;
  155. const float target_;
  156. };
  157. // GrayscaleTransition ---------------------------------------------------------
  158. class GrayscaleTransition : public LayerAnimationElement {
  159. public:
  160. GrayscaleTransition(float target, base::TimeDelta duration)
  161. : LayerAnimationElement(GRAYSCALE, duration),
  162. start_(0.0f),
  163. target_(target) {
  164. }
  165. GrayscaleTransition(const GrayscaleTransition&) = delete;
  166. GrayscaleTransition& operator=(const GrayscaleTransition&) = delete;
  167. ~GrayscaleTransition() override {}
  168. protected:
  169. std::string DebugName() const override { return "GrayscaleTransition"; }
  170. void OnStart(LayerAnimationDelegate* delegate) override {
  171. start_ = delegate->GetGrayscaleForAnimation();
  172. }
  173. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  174. delegate->SetGrayscaleFromAnimation(
  175. gfx::Tween::FloatValueBetween(t, start_, target_),
  176. PropertyChangeReason::FROM_ANIMATION);
  177. return true;
  178. }
  179. void OnGetTarget(TargetValue* target) const override {
  180. target->grayscale = target_;
  181. }
  182. void OnAbort(LayerAnimationDelegate* delegate) override {}
  183. private:
  184. float start_;
  185. const float target_;
  186. };
  187. // ColorTransition -------------------------------------------------------------
  188. class ColorTransition : public LayerAnimationElement {
  189. public:
  190. ColorTransition(SkColor target, base::TimeDelta duration)
  191. : LayerAnimationElement(COLOR, duration),
  192. start_(SK_ColorBLACK),
  193. target_(target) {
  194. }
  195. ColorTransition(const ColorTransition&) = delete;
  196. ColorTransition& operator=(const ColorTransition&) = delete;
  197. ~ColorTransition() override {}
  198. protected:
  199. std::string DebugName() const override { return "ColorTransition"; }
  200. void OnStart(LayerAnimationDelegate* delegate) override {
  201. start_ = delegate->GetColorForAnimation();
  202. }
  203. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  204. delegate->SetColorFromAnimation(
  205. gfx::Tween::ColorValueBetween(t, start_, target_),
  206. PropertyChangeReason::FROM_ANIMATION);
  207. return true;
  208. }
  209. void OnGetTarget(TargetValue* target) const override {
  210. target->color = target_;
  211. }
  212. void OnAbort(LayerAnimationDelegate* delegate) override {}
  213. private:
  214. SkColor start_;
  215. const SkColor target_;
  216. };
  217. // ClipRectTransition ----------------------------------------------------------
  218. class ClipRectTransition : public LayerAnimationElement {
  219. public:
  220. ClipRectTransition(const gfx::Rect& target, base::TimeDelta duration)
  221. : LayerAnimationElement(CLIP, duration), target_(target) {}
  222. ClipRectTransition(const ClipRectTransition&) = delete;
  223. ClipRectTransition& operator=(const ClipRectTransition&) = delete;
  224. ~ClipRectTransition() override {}
  225. protected:
  226. std::string DebugName() const override { return "ClipRectTransition"; }
  227. void OnStart(LayerAnimationDelegate* delegate) override {
  228. start_ = delegate->GetClipRectForAnimation();
  229. }
  230. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  231. delegate->SetClipRectFromAnimation(
  232. gfx::Tween::RectValueBetween(t, start_, target_),
  233. PropertyChangeReason::FROM_ANIMATION);
  234. return true;
  235. }
  236. void OnGetTarget(TargetValue* target) const override {
  237. target->clip_rect = target_;
  238. }
  239. void OnAbort(LayerAnimationDelegate* delegate) override {}
  240. private:
  241. gfx::Rect start_;
  242. const gfx::Rect target_;
  243. };
  244. // RoundedCornersTransition ----------------------------------------------------
  245. class RoundedCornersTransition : public LayerAnimationElement {
  246. public:
  247. RoundedCornersTransition(const gfx::RoundedCornersF& target,
  248. base::TimeDelta duration)
  249. : LayerAnimationElement(ROUNDED_CORNERS, duration), target_(target) {}
  250. RoundedCornersTransition(const RoundedCornersTransition&) = delete;
  251. RoundedCornersTransition& operator=(const RoundedCornersTransition&) = delete;
  252. ~RoundedCornersTransition() override = default;
  253. protected:
  254. std::string DebugName() const override { return "RoundedCornersTransition"; }
  255. void OnStart(LayerAnimationDelegate* delegate) override {
  256. start_ = delegate->GetRoundedCornersForAnimation();
  257. }
  258. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  259. delegate->SetRoundedCornersFromAnimation(
  260. gfx::RoundedCornersF(
  261. gfx::Tween::FloatValueBetween(t, start_.upper_left(),
  262. target_.upper_left()),
  263. gfx::Tween::FloatValueBetween(t, start_.upper_right(),
  264. target_.upper_right()),
  265. gfx::Tween::FloatValueBetween(t, start_.lower_right(),
  266. target_.lower_right()),
  267. gfx::Tween::FloatValueBetween(t, start_.lower_left(),
  268. target_.lower_left())),
  269. PropertyChangeReason::FROM_ANIMATION);
  270. return true;
  271. }
  272. void OnGetTarget(TargetValue* target) const override {
  273. target->rounded_corners = target_;
  274. }
  275. void OnAbort(LayerAnimationDelegate* delegate) override {}
  276. private:
  277. gfx::RoundedCornersF start_;
  278. gfx::RoundedCornersF target_;
  279. };
  280. // GradientMaskTransition ----------------------------------------------------
  281. class GradientMaskTransition : public LayerAnimationElement {
  282. public:
  283. GradientMaskTransition(const gfx::LinearGradient& target,
  284. base::TimeDelta duration)
  285. : LayerAnimationElement(GRADIENT_MASK, duration), target_(target) {}
  286. GradientMaskTransition(const GradientMaskTransition&) = delete;
  287. GradientMaskTransition& operator=(const GradientMaskTransition&) = delete;
  288. ~GradientMaskTransition() override = default;
  289. protected:
  290. std::string DebugName() const override { return "GradientMaskTransition"; }
  291. void OnStart(LayerAnimationDelegate* delegate) override {
  292. start_ = delegate->GetGradientMaskForAnimation();
  293. }
  294. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  295. auto gradient_mask = gfx::LinearGradient(
  296. gfx::Tween::FloatValueBetween(t, start_.angle(), target_.angle()));
  297. DCHECK_EQ(start_.step_count(), target_.step_count());
  298. for (auto i = 0; i < static_cast<int>(start_.step_count()); ++i) {
  299. gradient_mask.AddStep(
  300. gfx::Tween::FloatValueBetween(t, start_.steps()[i].fraction,
  301. target_.steps()[i].fraction),
  302. gfx::Tween::IntValueBetween(t, start_.steps()[i].alpha,
  303. target_.steps()[i].alpha));
  304. }
  305. delegate->SetGradientMaskFromAnimation(
  306. gradient_mask, PropertyChangeReason::FROM_ANIMATION);
  307. return true;
  308. }
  309. void OnGetTarget(TargetValue* target) const override {
  310. target->gradient_mask = target_;
  311. }
  312. void OnAbort(LayerAnimationDelegate* delegate) override {}
  313. private:
  314. gfx::LinearGradient start_;
  315. const gfx::LinearGradient target_;
  316. };
  317. // ThreadedLayerAnimationElement -----------------------------------------------
  318. class ThreadedLayerAnimationElement : public LayerAnimationElement {
  319. public:
  320. ThreadedLayerAnimationElement(AnimatableProperties properties,
  321. base::TimeDelta duration)
  322. : LayerAnimationElement(properties, duration) {
  323. }
  324. ThreadedLayerAnimationElement(const ThreadedLayerAnimationElement&) = delete;
  325. ThreadedLayerAnimationElement& operator=(
  326. const ThreadedLayerAnimationElement&) = delete;
  327. ~ThreadedLayerAnimationElement() override {}
  328. bool IsThreaded(LayerAnimationDelegate* delegate) const override {
  329. return !duration().is_zero();
  330. }
  331. protected:
  332. explicit ThreadedLayerAnimationElement(const LayerAnimationElement& element)
  333. : LayerAnimationElement(element) {
  334. }
  335. std::string DebugName() const override {
  336. return "ThreadedLayerAnimationElement";
  337. }
  338. bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
  339. if (t < 1.0)
  340. return false;
  341. if (Started() && IsThreaded(delegate)) {
  342. LayerThreadedAnimationDelegate* threaded =
  343. delegate->GetThreadedAnimationDelegate();
  344. DCHECK(threaded);
  345. threaded->RemoveThreadedAnimation(keyframe_model_id());
  346. }
  347. OnEnd(delegate);
  348. return true;
  349. }
  350. void OnAbort(LayerAnimationDelegate* delegate) override {
  351. if (delegate && Started() && IsThreaded(delegate)) {
  352. LayerThreadedAnimationDelegate* threaded =
  353. delegate->GetThreadedAnimationDelegate();
  354. DCHECK(threaded);
  355. threaded->RemoveThreadedAnimation(keyframe_model_id());
  356. }
  357. }
  358. void RequestEffectiveStart(LayerAnimationDelegate* delegate) override {
  359. DCHECK(animation_group_id());
  360. if (!IsThreaded(delegate)) {
  361. set_effective_start_time(requested_start_time());
  362. return;
  363. }
  364. set_effective_start_time(base::TimeTicks());
  365. std::unique_ptr<cc::KeyframeModel> keyframe_model = CreateCCKeyframeModel();
  366. keyframe_model->set_needs_synchronized_start_time(true);
  367. LayerThreadedAnimationDelegate* threaded =
  368. delegate->GetThreadedAnimationDelegate();
  369. DCHECK(threaded);
  370. threaded->AddThreadedAnimation(std::move(keyframe_model));
  371. }
  372. virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
  373. virtual std::unique_ptr<cc::KeyframeModel> CreateCCKeyframeModel() = 0;
  374. };
  375. // ThreadedOpacityTransition ---------------------------------------------------
  376. class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
  377. public:
  378. ThreadedOpacityTransition(float target, base::TimeDelta duration)
  379. : ThreadedLayerAnimationElement(OPACITY, duration),
  380. start_(0.0f),
  381. target_(target) {
  382. }
  383. ThreadedOpacityTransition(const ThreadedOpacityTransition&) = delete;
  384. ThreadedOpacityTransition& operator=(const ThreadedOpacityTransition&) =
  385. delete;
  386. ~ThreadedOpacityTransition() override {}
  387. protected:
  388. std::string DebugName() const override { return "ThreadedOpacityTransition"; }
  389. void OnStart(LayerAnimationDelegate* delegate) override {
  390. start_ = delegate->GetOpacityForAnimation();
  391. delegate->SetOpacityFromAnimation(delegate->GetOpacityForAnimation(),
  392. PropertyChangeReason::FROM_ANIMATION);
  393. }
  394. void OnAbort(LayerAnimationDelegate* delegate) override {
  395. if (delegate && Started()) {
  396. ThreadedLayerAnimationElement::OnAbort(delegate);
  397. delegate->SetOpacityFromAnimation(
  398. gfx::Tween::FloatValueBetween(
  399. gfx::Tween::CalculateValue(tween_type(),
  400. last_progressed_fraction()),
  401. start_, target_),
  402. PropertyChangeReason::FROM_ANIMATION);
  403. }
  404. }
  405. void OnEnd(LayerAnimationDelegate* delegate) override {
  406. delegate->SetOpacityFromAnimation(target_,
  407. PropertyChangeReason::FROM_ANIMATION);
  408. }
  409. std::unique_ptr<cc::KeyframeModel> CreateCCKeyframeModel() override {
  410. // Ensures that we don't remove and add a model with the same id in a single
  411. // frame.
  412. UpdateKeyframeModelId();
  413. std::unique_ptr<gfx::AnimationCurve> animation_curve(
  414. new FloatAnimationCurveAdapter(tween_type(), start_, target_,
  415. duration()));
  416. std::unique_ptr<cc::KeyframeModel> keyframe_model(cc::KeyframeModel::Create(
  417. std::move(animation_curve), keyframe_model_id(), animation_group_id(),
  418. cc::KeyframeModel::TargetPropertyId(cc::TargetProperty::OPACITY)));
  419. return keyframe_model;
  420. }
  421. void OnGetTarget(TargetValue* target) const override {
  422. target->opacity = target_;
  423. }
  424. bool IsThreaded(LayerAnimationDelegate* delegate) const override {
  425. // If the start and target values are the same, we do not create cc
  426. // animation so that we will not create render pass in this case.
  427. // http://crbug.com/764575.
  428. if (duration().is_zero())
  429. return false;
  430. if (Started())
  431. return start_ != target_;
  432. return delegate->GetOpacityForAnimation() != target_;
  433. }
  434. private:
  435. float start_;
  436. const float target_;
  437. };
  438. // ThreadedTransformTransition -------------------------------------------------
  439. class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
  440. public:
  441. ThreadedTransformTransition(const gfx::Transform& target,
  442. base::TimeDelta duration)
  443. : ThreadedLayerAnimationElement(TRANSFORM, duration),
  444. target_(target) {
  445. }
  446. ThreadedTransformTransition(const ThreadedTransformTransition&) = delete;
  447. ThreadedTransformTransition& operator=(const ThreadedTransformTransition&) =
  448. delete;
  449. ~ThreadedTransformTransition() override {}
  450. protected:
  451. std::string DebugName() const override {
  452. return "ThreadedTransformTransition";
  453. }
  454. void OnStart(LayerAnimationDelegate* delegate) override {
  455. start_ = delegate->GetTransformForAnimation();
  456. delegate->SetTransformFromAnimation(delegate->GetTransformForAnimation(),
  457. PropertyChangeReason::FROM_ANIMATION);
  458. }
  459. void OnAbort(LayerAnimationDelegate* delegate) override {
  460. if (delegate && Started()) {
  461. ThreadedLayerAnimationElement::OnAbort(delegate);
  462. delegate->SetTransformFromAnimation(
  463. gfx::Tween::TransformValueBetween(
  464. gfx::Tween::CalculateValue(tween_type(),
  465. last_progressed_fraction()),
  466. start_, target_),
  467. PropertyChangeReason::FROM_ANIMATION);
  468. }
  469. }
  470. void OnEnd(LayerAnimationDelegate* delegate) override {
  471. delegate->SetTransformFromAnimation(target_,
  472. PropertyChangeReason::FROM_ANIMATION);
  473. }
  474. std::unique_ptr<cc::KeyframeModel> CreateCCKeyframeModel() override {
  475. // Ensures that we don't remove and add a model with the same id in a single
  476. // frame.
  477. UpdateKeyframeModelId();
  478. std::unique_ptr<gfx::AnimationCurve> animation_curve(
  479. new TransformAnimationCurveAdapter(tween_type(), start_, target_,
  480. duration()));
  481. std::unique_ptr<cc::KeyframeModel> keyframe_model(cc::KeyframeModel::Create(
  482. std::move(animation_curve), keyframe_model_id(), animation_group_id(),
  483. cc::KeyframeModel::TargetPropertyId(cc::TargetProperty::TRANSFORM)));
  484. return keyframe_model;
  485. }
  486. void OnGetTarget(TargetValue* target) const override {
  487. target->transform = target_;
  488. }
  489. private:
  490. gfx::Transform start_;
  491. const gfx::Transform target_;
  492. };
  493. } // namespace
  494. // LayerAnimationElement::TargetValue ------------------------------------------
  495. LayerAnimationElement::TargetValue::TargetValue()
  496. : opacity(0.0f),
  497. visibility(false),
  498. brightness(0.0f),
  499. grayscale(0.0f),
  500. color(SK_ColorBLACK) {
  501. }
  502. LayerAnimationElement::TargetValue::TargetValue(
  503. const LayerAnimationDelegate* delegate)
  504. : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
  505. transform(delegate ? delegate->GetTransformForAnimation()
  506. : gfx::Transform()),
  507. opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
  508. visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
  509. brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
  510. grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
  511. color(delegate ? delegate->GetColorForAnimation() : SK_ColorTRANSPARENT),
  512. clip_rect(delegate ? delegate->GetClipRectForAnimation() : gfx::Rect()),
  513. rounded_corners(delegate ? delegate->GetRoundedCornersForAnimation()
  514. : gfx::RoundedCornersF()),
  515. gradient_mask(delegate ? delegate->GetGradientMaskForAnimation()
  516. : gfx::LinearGradient::GetEmpty()) {}
  517. // LayerAnimationElement -------------------------------------------------------
  518. LayerAnimationElement::LayerAnimationElement(AnimatableProperties properties,
  519. base::TimeDelta duration)
  520. : first_frame_(true),
  521. properties_(properties),
  522. duration_(GetEffectiveDuration(duration)),
  523. tween_type_(gfx::Tween::LINEAR),
  524. keyframe_model_id_(cc::AnimationIdProvider::NextKeyframeModelId()),
  525. animation_group_id_(0),
  526. last_progressed_fraction_(0.0) {}
  527. LayerAnimationElement::LayerAnimationElement(
  528. const LayerAnimationElement& element)
  529. : first_frame_(element.first_frame_),
  530. properties_(element.properties_),
  531. duration_(element.duration_),
  532. tween_type_(element.tween_type_),
  533. keyframe_model_id_(cc::AnimationIdProvider::NextKeyframeModelId()),
  534. animation_group_id_(element.animation_group_id_),
  535. last_progressed_fraction_(element.last_progressed_fraction_) {}
  536. LayerAnimationElement::~LayerAnimationElement() = default;
  537. void LayerAnimationElement::Start(LayerAnimationDelegate* delegate,
  538. int animation_group_id) {
  539. DCHECK(requested_start_time_ != base::TimeTicks());
  540. DCHECK(first_frame_);
  541. animation_group_id_ = animation_group_id;
  542. last_progressed_fraction_ = 0.0;
  543. OnStart(delegate);
  544. RequestEffectiveStart(delegate);
  545. first_frame_ = false;
  546. }
  547. bool LayerAnimationElement::Progress(base::TimeTicks now,
  548. LayerAnimationDelegate* delegate) {
  549. DCHECK(requested_start_time_ != base::TimeTicks());
  550. DCHECK(!first_frame_);
  551. bool need_draw;
  552. double t = 1.0;
  553. if ((effective_start_time_ == base::TimeTicks()) ||
  554. (now < effective_start_time_)) {
  555. // This hasn't actually started yet.
  556. need_draw = false;
  557. last_progressed_fraction_ = 0.0;
  558. return need_draw;
  559. }
  560. base::TimeDelta elapsed = now - effective_start_time_;
  561. if ((duration_.is_positive()) && (elapsed < duration_))
  562. t = elapsed / duration_;
  563. base::WeakPtr<LayerAnimationElement> alive(weak_ptr_factory_.GetWeakPtr());
  564. need_draw = OnProgress(gfx::Tween::CalculateValue(tween_type_, t), delegate);
  565. if (!alive)
  566. return need_draw;
  567. first_frame_ = t == 1.0;
  568. last_progressed_fraction_ = t;
  569. return need_draw;
  570. }
  571. bool LayerAnimationElement::IsFinished(base::TimeTicks time,
  572. base::TimeDelta* total_duration) {
  573. // If an effective start has been requested but the effective start time
  574. // hasn't yet been set, the keyframe_model is not finished, regardless of the
  575. // value of |time|.
  576. if (!first_frame_ && (effective_start_time_ == base::TimeTicks()))
  577. return false;
  578. base::TimeDelta queueing_delay;
  579. if (!first_frame_)
  580. queueing_delay = effective_start_time_ - requested_start_time_;
  581. base::TimeDelta elapsed = time - requested_start_time_;
  582. if (elapsed >= duration_ + queueing_delay) {
  583. *total_duration = duration_ + queueing_delay;
  584. return true;
  585. }
  586. return false;
  587. }
  588. bool LayerAnimationElement::ProgressToEnd(LayerAnimationDelegate* delegate) {
  589. if (first_frame_)
  590. OnStart(delegate);
  591. base::WeakPtr<LayerAnimationElement> alive(weak_ptr_factory_.GetWeakPtr());
  592. bool need_draw = OnProgress(1.0, delegate);
  593. if (!alive)
  594. return need_draw;
  595. last_progressed_fraction_ = 1.0;
  596. first_frame_ = true;
  597. return need_draw;
  598. }
  599. void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
  600. OnGetTarget(target);
  601. }
  602. bool LayerAnimationElement::IsThreaded(LayerAnimationDelegate* delegate) const {
  603. return false;
  604. }
  605. void LayerAnimationElement::Abort(LayerAnimationDelegate* delegate) {
  606. OnAbort(delegate);
  607. first_frame_ = true;
  608. }
  609. void LayerAnimationElement::RequestEffectiveStart(
  610. LayerAnimationDelegate* delegate) {
  611. DCHECK(requested_start_time_ != base::TimeTicks());
  612. effective_start_time_ = requested_start_time_;
  613. }
  614. std::string LayerAnimationElement::ToString() const {
  615. // TODO(wkorman): Add support for subclasses to tack on more info
  616. // beyond just their name.
  617. return base::StringPrintf(
  618. "LayerAnimationElement{name=%s, id=%d, group=%d, "
  619. "last_progressed_fraction=%0.2f}",
  620. DebugName().c_str(), keyframe_model_id_, animation_group_id_,
  621. last_progressed_fraction_);
  622. }
  623. void LayerAnimationElement::UpdateKeyframeModelId() {
  624. keyframe_model_id_ = cc::AnimationIdProvider::NextKeyframeModelId();
  625. }
  626. std::string LayerAnimationElement::DebugName() const {
  627. return "Default";
  628. }
  629. // static
  630. LayerAnimationElement::AnimatableProperty
  631. LayerAnimationElement::ToAnimatableProperty(cc::TargetProperty::Type property) {
  632. switch (property) {
  633. case cc::TargetProperty::TRANSFORM:
  634. return TRANSFORM;
  635. case cc::TargetProperty::OPACITY:
  636. return OPACITY;
  637. default:
  638. NOTREACHED();
  639. return AnimatableProperty();
  640. }
  641. }
  642. // static
  643. std::string LayerAnimationElement::AnimatablePropertiesToString(
  644. AnimatableProperties properties) {
  645. std::string str;
  646. int property_count = 0;
  647. for (unsigned i = FIRST_PROPERTY; i != SENTINEL; i = i << 1) {
  648. if (i & properties) {
  649. LayerAnimationElement::AnimatableProperty property =
  650. static_cast<LayerAnimationElement::AnimatableProperty>(i);
  651. if (property_count > 0)
  652. str.append("|");
  653. // TODO(wkorman): Consider reworking enum definition to follow
  654. // #define pattern that includes easier string output.
  655. switch (property) {
  656. case UNKNOWN:
  657. str.append("UNKNOWN");
  658. break;
  659. case TRANSFORM:
  660. str.append("TRANSFORM");
  661. break;
  662. case BOUNDS:
  663. str.append("BOUNDS");
  664. break;
  665. case OPACITY:
  666. str.append("OPACITY");
  667. break;
  668. case VISIBILITY:
  669. str.append("VISIBILITY");
  670. break;
  671. case BRIGHTNESS:
  672. str.append("BRIGHTNESS");
  673. break;
  674. case GRAYSCALE:
  675. str.append("GRAYSCALE");
  676. break;
  677. case COLOR:
  678. str.append("COLOR");
  679. break;
  680. case CLIP:
  681. str.append("CLIP");
  682. break;
  683. case ROUNDED_CORNERS:
  684. str.append("ROUNDED_CORNERS");
  685. break;
  686. case GRADIENT_MASK:
  687. str.append("GRADIENT_MASK");
  688. break;
  689. case SENTINEL:
  690. NOTREACHED();
  691. break;
  692. }
  693. property_count++;
  694. }
  695. }
  696. return str;
  697. }
  698. // static
  699. base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
  700. const base::TimeDelta& duration) {
  701. if (ScopedAnimationDurationScaleMode::duration_multiplier() == 0)
  702. return base::TimeDelta();
  703. return duration * ScopedAnimationDurationScaleMode::duration_multiplier();
  704. }
  705. // static
  706. std::unique_ptr<LayerAnimationElement>
  707. LayerAnimationElement::CreateTransformElement(const gfx::Transform& transform,
  708. base::TimeDelta duration) {
  709. return std::make_unique<ThreadedTransformTransition>(transform, duration);
  710. }
  711. // static
  712. std::unique_ptr<LayerAnimationElement>
  713. LayerAnimationElement::CreateInterpolatedTransformElement(
  714. std::unique_ptr<InterpolatedTransform> interpolated_transform,
  715. base::TimeDelta duration) {
  716. return std::make_unique<InterpolatedTransformTransition>(
  717. std::move(interpolated_transform), duration);
  718. }
  719. // static
  720. std::unique_ptr<LayerAnimationElement>
  721. LayerAnimationElement::CreateBoundsElement(const gfx::Rect& bounds,
  722. base::TimeDelta duration) {
  723. return std::make_unique<BoundsTransition>(bounds, duration);
  724. }
  725. // static
  726. std::unique_ptr<LayerAnimationElement>
  727. LayerAnimationElement::CreateOpacityElement(float opacity,
  728. base::TimeDelta duration) {
  729. return std::make_unique<ThreadedOpacityTransition>(opacity, duration);
  730. }
  731. // static
  732. std::unique_ptr<LayerAnimationElement>
  733. LayerAnimationElement::CreateVisibilityElement(bool visibility,
  734. base::TimeDelta duration) {
  735. return std::make_unique<VisibilityTransition>(visibility, duration);
  736. }
  737. // static
  738. std::unique_ptr<LayerAnimationElement>
  739. LayerAnimationElement::CreateBrightnessElement(float brightness,
  740. base::TimeDelta duration) {
  741. return std::make_unique<BrightnessTransition>(brightness, duration);
  742. }
  743. // static
  744. std::unique_ptr<LayerAnimationElement>
  745. LayerAnimationElement::CreateGrayscaleElement(float grayscale,
  746. base::TimeDelta duration) {
  747. return std::make_unique<GrayscaleTransition>(grayscale, duration);
  748. }
  749. // static
  750. std::unique_ptr<LayerAnimationElement>
  751. LayerAnimationElement::CreatePauseElement(AnimatableProperties properties,
  752. base::TimeDelta duration) {
  753. return std::make_unique<Pause>(properties, duration);
  754. }
  755. // static
  756. std::unique_ptr<LayerAnimationElement>
  757. LayerAnimationElement::CreateColorElement(SkColor color,
  758. base::TimeDelta duration) {
  759. return std::make_unique<ColorTransition>(color, duration);
  760. }
  761. std::unique_ptr<LayerAnimationElement>
  762. LayerAnimationElement::CreateClipRectElement(const gfx::Rect& clip_rect,
  763. base::TimeDelta duration) {
  764. return std::make_unique<ClipRectTransition>(clip_rect, duration);
  765. }
  766. std::unique_ptr<LayerAnimationElement>
  767. LayerAnimationElement::CreateRoundedCornersElement(
  768. const gfx::RoundedCornersF& rounded_corners,
  769. base::TimeDelta duration) {
  770. return std::make_unique<RoundedCornersTransition>(rounded_corners, duration);
  771. }
  772. std::unique_ptr<LayerAnimationElement>
  773. LayerAnimationElement::CreateGradientMaskElement(
  774. const gfx::LinearGradient& gradient_mask,
  775. base::TimeDelta duration) {
  776. return std::make_unique<GradientMaskTransition>(gradient_mask, duration);
  777. }
  778. } // namespace ui