mojo/services/view_manager/scheduled_animation_group.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 "mojo/services/view_manager/scheduled_animation_group.h"
   6
   7 #include <set>
   8
   9 #include "mojo/converters/geometry/geometry_type_converters.h"
  10 #include "mojo/converters/transform/transform_type_converters.h"
  11 #include "mojo/services/view_manager/server_view.h"
  12
  13 using mojo::ANIMATION_PROPERTY_NONE;
  14 using mojo::ANIMATION_PROPERTY_OPACITY;
  15 using mojo::ANIMATION_PROPERTY_TRANSFORM;
  16 using mojo::AnimationProperty;
  17
  18 namespace view_manager {
  19 namespace {
  20
  21 using Sequences = std::vector<ScheduledAnimationSequence>;
  22
  23 // Gets the value of |property| from |view| into |value|.
  24 void GetValueFromView(const ServerView* view,
  25                       AnimationProperty property,
  26                       ScheduledAnimationValue* value) {
  27   switch (property) {
  28     case ANIMATION_PROPERTY_NONE:
  29       NOTREACHED();
  30       break;
  31     case ANIMATION_PROPERTY_OPACITY:
  32       value->float_value = view->opacity();
  33       break;
  34     case ANIMATION_PROPERTY_TRANSFORM:
  35       value->transform = view->transform();
  36       break;
  37   }
  38 }
  39
  40 // Sets the value of |property| from |value| into |view|.
  41 void SetViewPropertyFromValue(ServerView* view,
  42                               AnimationProperty property,
  43                               const ScheduledAnimationValue& value) {
  44   switch (property) {
  45     case ANIMATION_PROPERTY_NONE:
  46       break;
  47     case ANIMATION_PROPERTY_OPACITY:
  48       view->SetOpacity(value.float_value);
  49       break;
  50     case ANIMATION_PROPERTY_TRANSFORM:
  51       view->SetTransform(value.transform);
  52       break;
  53   }
  54 }
  55
  56 // Sets the value of |property| into |view| between two points.
  57 void SetViewPropertyFromValueBetween(ServerView* view,
  58                                      AnimationProperty property,
  59                                      double value,
  60                                      gfx::Tween::Type tween_type,
  61                                      const ScheduledAnimationValue& start,
  62                                      const ScheduledAnimationValue& target) {
  63   const double tween_value = gfx::Tween::CalculateValue(tween_type, value);
  64   switch (property) {
  65     case ANIMATION_PROPERTY_NONE:
  66       break;
  67     case ANIMATION_PROPERTY_OPACITY:
  68       view->SetOpacity(gfx::Tween::FloatValueBetween(
  69           tween_value, start.float_value, target.float_value));
  70       break;
  71     case ANIMATION_PROPERTY_TRANSFORM:
  72       view->SetTransform(gfx::Tween::TransformValueBetween(
  73           tween_value, start.transform, target.transform));
  74       break;
  75   }
  76 }
  77
  78 gfx::Tween::Type AnimationTypeToTweenType(mojo::AnimationTweenType type) {
  79   switch (type) {
  80     case mojo::ANIMATION_TWEEN_TYPE_LINEAR:
  81       return gfx::Tween::LINEAR;
  82     case mojo::ANIMATION_TWEEN_TYPE_EASE_IN:
  83       return gfx::Tween::EASE_IN;
  84     case mojo::ANIMATION_TWEEN_TYPE_EASE_OUT:
  85       return gfx::Tween::EASE_OUT;
  86     case mojo::ANIMATION_TWEEN_TYPE_EASE_IN_OUT:
  87       return gfx::Tween::EASE_IN_OUT;
  88   }
  89   return gfx::Tween::LINEAR;
  90 }
  91
  92 void ConvertToScheduledValue(const mojo::AnimationValue& transport_value,
  93                              ScheduledAnimationValue* value) {
  94   value->float_value = transport_value.float_value;
  95   value->transform = transport_value.transform.To<gfx::Transform>();
  96 }
  97
  98 void ConvertToScheduledElement(const mojo::AnimationElement& transport_element,
  99                                ScheduledAnimationElement* element) {
 100   element->property = transport_element.property;
 101   element->duration =
 102       base::TimeDelta::FromMicroseconds(transport_element.duration);
 103   element->tween_type = AnimationTypeToTweenType(transport_element.tween_type);
 104   if (transport_element.property != ANIMATION_PROPERTY_NONE) {
 105     if (transport_element.start_value.get()) {
 106       element->is_start_valid = true;
 107       ConvertToScheduledValue(*transport_element.start_value,
 108                               &(element->start_value));
 109     } else {
 110       element->is_start_valid = false;
 111     }
 112     ConvertToScheduledValue(*transport_element.target_value,
 113                             &(element->target_value));
 114   }
 115 }
 116
 117 bool IsAnimationValueValid(AnimationProperty property,
 118                            const mojo::AnimationValue& value) {
 119   switch (property) {
 120     case ANIMATION_PROPERTY_NONE:
 121       NOTREACHED();
 122       return false;
 123     case ANIMATION_PROPERTY_OPACITY:
 124       return value.float_value >= 0.f && value.float_value <= 1.f;
 125     case ANIMATION_PROPERTY_TRANSFORM:
 126       return value.transform.get() && value.transform->matrix.size() == 16u;
 127   }
 128   return false;
 129 }
 130
 131 bool IsAnimationElementValid(const mojo::AnimationElement& element) {
 132   if (element.property == ANIMATION_PROPERTY_NONE)
 133     return true;  // None is a pause and doesn't need any values.
 134   if (element.start_value.get() &&
 135       !IsAnimationValueValid(element.property, *element.start_value))
 136     return false;
 137   // For all other properties we require a target.
 138   return element.target_value.get() &&
 139          IsAnimationValueValid(element.property, *element.target_value);
 140 }
 141
 142 bool IsAnimationSequenceValid(const mojo::AnimationSequence& sequence) {
 143   if (sequence.elements.size() == 0u)
 144     return false;
 145
 146   for (size_t i = 0; i < sequence.elements.size(); ++i) {
 147     if (!IsAnimationElementValid(*sequence.elements[i]))
 148       return false;
 149   }
 150   return true;
 151 }
 152
 153 bool IsAnimationGroupValid(const mojo::AnimationGroup& transport_group) {
 154   if (transport_group.sequences.size() == 0u)
 155     return false;
 156   for (size_t i = 0; i < transport_group.sequences.size(); ++i) {
 157     if (!IsAnimationSequenceValid(*transport_group.sequences[i]))
 158       return false;
 159   }
 160   return true;
 161 }
 162
 163 // If the start value for |element| isn't valid, the value for the property
 164 // is obtained from |view| and placed into |element|.
 165 void GetStartValueFromViewIfNecessary(const ServerView* view,
 166                                       ScheduledAnimationElement* element) {
 167   if (element->property != ANIMATION_PROPERTY_NONE &&
 168       !element->is_start_valid) {
 169     GetValueFromView(view, element->property, &(element->start_value));
 170   }
 171 }
 172
 173 void GetScheduledAnimationProperties(const Sequences& sequences,
 174                                      std::set<AnimationProperty>* properties) {
 175   for (const ScheduledAnimationSequence& sequence : sequences) {
 176     for (const ScheduledAnimationElement& element : sequence.elements)
 177       properties->insert(element.property);
 178   }
 179 }
 180
 181 void SetPropertyToTargetProperty(ServerView* view,
 182                                  mojo::AnimationProperty property,
 183                                  const Sequences& sequences) {
 184   // NOTE: this doesn't deal with |cycle_count| quite right, but I'm honestly
 185   // not sure we really want to support the same property in multiple sequences
 186   // animating at once so I'm not dealing.
 187   base::TimeDelta max_end_duration;
 188   scoped_ptr<ScheduledAnimationValue> value;
 189   for (const ScheduledAnimationSequence& sequence : sequences) {
 190     base::TimeDelta duration;
 191     for (const ScheduledAnimationElement& element : sequence.elements) {
 192       if (element.property != property)
 193         continue;
 194
 195       duration += element.duration;
 196       if (duration > max_end_duration) {
 197         max_end_duration = duration;
 198         value.reset(new ScheduledAnimationValue(element.target_value));
 199       }
 200     }
 201   }
 202   if (value.get())
 203     SetViewPropertyFromValue(view, property, *value);
 204 }
 205
 206 void ConvertSequenceToScheduled(
 207     const mojo::AnimationSequence& transport_sequence,
 208     base::TimeTicks now,
 209     ScheduledAnimationSequence* sequence) {
 210   sequence->run_until_stopped = transport_sequence.cycle_count == 0u;
 211   sequence->cycle_count = transport_sequence.cycle_count;
 212   DCHECK_NE(0u, transport_sequence.elements.size());
 213   sequence->elements.resize(transport_sequence.elements.size());
 214
 215   base::TimeTicks element_start_time = now;
 216   for (size_t i = 0; i < transport_sequence.elements.size(); ++i) {
 217     ConvertToScheduledElement(*(transport_sequence.elements[i].get()),
 218                               &(sequence->elements[i]));
 219     sequence->elements[i].start_time = element_start_time;
 220     sequence->duration += sequence->elements[i].duration;
 221     element_start_time += sequence->elements[i].duration;
 222   }
 223 }
 224
 225 bool AdvanceSequence(ServerView* view,
 226                      ScheduledAnimationSequence* sequence,
 227                      base::TimeTicks now) {
 228   ScheduledAnimationElement* element =
 229       &(sequence->elements[sequence->current_index]);
 230   while (element->start_time + element->duration < now) {
 231     SetViewPropertyFromValue(view, element->property, element->target_value);
 232     if (++sequence->current_index == sequence->elements.size()) {
 233       if (!sequence->run_until_stopped && --sequence->cycle_count == 0) {
 234         SetViewPropertyFromValue(view, element->property,
 235                                  element->target_value);
 236         return false;
 237       }
 238
 239       sequence->current_index = 0;
 240     }
 241     sequence->elements[sequence->current_index].start_time =
 242         element->start_time + element->duration;
 243     element = &(sequence->elements[sequence->current_index]);
 244     GetStartValueFromViewIfNecessary(view, element);
 245
 246     // It's possible for the delta between now and |last_tick_time_| to be very
 247     // big (could happen if machine sleeps and is woken up much later). Normally
 248     // the repeat count is smallish, so we don't bother optimizing it. OTOH if
 249     // a sequence repeats forever we optimize it lest we get stuck in this loop
 250     // for a very long time.
 251     if (sequence->run_until_stopped && sequence->current_index == 0) {
 252       element->start_time =
 253           now - base::TimeDelta::FromMicroseconds(
 254                     (now - element->start_time).InMicroseconds() %
 255                     sequence->duration.InMicroseconds());
 256     }
 257   }
 258   return true;
 259 }
 260
 261 }  // namespace
 262
 263 ScheduledAnimationValue::ScheduledAnimationValue() {
 264 }
 265 ScheduledAnimationValue::~ScheduledAnimationValue() {
 266 }
 267
 268 ScheduledAnimationElement::ScheduledAnimationElement()
 269     : property(ANIMATION_PROPERTY_OPACITY),
 270       tween_type(gfx::Tween::EASE_IN),
 271       is_start_valid(false) {
 272 }
 273 ScheduledAnimationElement::~ScheduledAnimationElement() {
 274 }
 275
 276 ScheduledAnimationSequence::ScheduledAnimationSequence()
 277     : run_until_stopped(false), cycle_count(0), current_index(0u) {
 278 }
 279 ScheduledAnimationSequence::~ScheduledAnimationSequence() {
 280 }
 281
 282 ScheduledAnimationGroup::~ScheduledAnimationGroup() {
 283 }
 284
 285 // static
 286 scoped_ptr<ScheduledAnimationGroup> ScheduledAnimationGroup::Create(
 287     ServerView* view,
 288     base::TimeTicks now,
 289     uint32_t id,
 290     const mojo::AnimationGroup& transport_group) {
 291   if (!IsAnimationGroupValid(transport_group))
 292     return nullptr;
 293
 294   scoped_ptr<ScheduledAnimationGroup> group(
 295       new ScheduledAnimationGroup(view, id, now));
 296   group->sequences_.resize(transport_group.sequences.size());
 297   for (size_t i = 0; i < transport_group.sequences.size(); ++i) {
 298     const mojo::AnimationSequence& transport_sequence(
 299         *(transport_group.sequences[i]));
 300     DCHECK_NE(0u, transport_sequence.elements.size());
 301     ConvertSequenceToScheduled(transport_sequence, now, &group->sequences_[i]);
 302   }
 303   return group.Pass();
 304 }
 305
 306 void ScheduledAnimationGroup::ObtainStartValues() {
 307   for (ScheduledAnimationSequence& sequence : sequences_)
 308     GetStartValueFromViewIfNecessary(view_, &(sequence.elements[0]));
 309 }
 310
 311 void ScheduledAnimationGroup::SetValuesToTargetValuesForPropertiesNotIn(
 312     const ScheduledAnimationGroup& other) {
 313   std::set<AnimationProperty> our_properties;
 314   GetScheduledAnimationProperties(sequences_, &our_properties);
 315
 316   std::set<AnimationProperty> other_properties;
 317   GetScheduledAnimationProperties(other.sequences_, &other_properties);
 318
 319   for (AnimationProperty property : our_properties) {
 320     if (other_properties.count(property) == 0 &&
 321         property != ANIMATION_PROPERTY_NONE) {
 322       SetPropertyToTargetProperty(view_, property, sequences_);
 323     }
 324   }
 325 }
 326
 327 bool ScheduledAnimationGroup::Tick(base::TimeTicks time) {
 328   for (Sequences::iterator i = sequences_.begin(); i != sequences_.end();) {
 329     if (!AdvanceSequence(view_, &(*i), time)) {
 330       i = sequences_.erase(i);
 331       continue;
 332     }
 333     const ScheduledAnimationElement& active_element(
 334         i->elements[i->current_index]);
 335     const double percent =
 336         (time - active_element.start_time).InMillisecondsF() /
 337         active_element.duration.InMillisecondsF();
 338     SetViewPropertyFromValueBetween(
 339         view_, active_element.property, percent, active_element.tween_type,
 340         active_element.start_value, active_element.target_value);
 341     ++i;
 342   }
 343   return sequences_.empty();
 344 }
 345
 346 ScheduledAnimationGroup::ScheduledAnimationGroup(ServerView* view,
 347                                                  uint32_t id,
 348                                                  base::TimeTicks time_scheduled)
 349     : view_(view), id_(id), time_scheduled_(time_scheduled) {
 350 }
 351
 352 }  // namespace view_manager