Add VR Shell animation classes and unit test.

chrome/browser/android/vr_shell/ui_elements.cc

Index: chrome/browser/android/vr_shell/ui_elements.cc
diff --git a/chrome/browser/android/vr_shell/ui_elements.cc b/chrome/browser/android/vr_shell/ui_elements.cc
index ce2bcbbc22c2b72095d2c963045fe24757047422..8b8d7f774f59f3cbe4134769e071da483f976b2f 100644
--- a/chrome/browser/android/vr_shell/ui_elements.cc
+++ b/chrome/browser/android/vr_shell/ui_elements.cc
@@ -5,7 +5,8 @@
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 
 #include <cmath>
-#include <vector>
+
+#include "chrome/browser/android/vr_shell/animation.h"
 
 namespace vr_shell {
 
@@ -86,5 +87,95 @@ ContentRectangle::ContentRectangle() = default;
 
 ContentRectangle::~ContentRectangle() = default;
 
+void ContentRectangle::Animate(int64_t time) {
+  for (auto& it : animations) {
+    Animation& animation = *it;

[David Trainor- moved to gerrit, 2016/09/14 21:43:30]

Does it make sense to push this logic into Animation?

Random thoughts on this:
Could you build an Animation that knew how to modify a gvr::Vec3 or a Rectf? 
Then you could just call Animation::Animate(time) and let it do the magic
internally?

There are a lot of ways to flesh that out.  Just a thought.

[mthiesse, 2016/09/14 22:15:21]

(Full disclosure, I wrote this code originally :P)

There are various problems with various ways of doing this. We want to avoid
circular dependencies between Animation and ContentRectangle, and we want
ContentRectangle to manage the lifetime of the Animation.

Animation::Animate(time) suggests that we have either many Animation
constructors, many Animation subclasses, or Animation depends on
ContentRectangle, and that we also maintain pointers to the things we're
animating in Animation, which seems like a major pain.

Animation::Animate(time, gvr::Vec3&/Rectf&/etc.) with a few overloads could
work, with Animation being constructed with from/to vectors, though I'm not sure
how much better the code would look as we'd still need a switch statement here
to figure out which property is being animated.

[cjgrant, 2016/09/16 17:47:08]

Personally, I'd like to keep Animation as basically descriptor, leaving the
application to clients.  Later on, if we start duplicating application code,
we'll have a better sense of how to best generalize it here.  Is that okay?

+    if (time < animation.start)
+      continue;
+
+    // If |from| is not specified, start at the current values.
+    if (animation.from.size() == 0) {
+      switch (animation.property) {
+        case Animation::COPYRECT:
+          animation.from.push_back(copy_rect.x);
+          animation.from.push_back(copy_rect.y);
+          animation.from.push_back(copy_rect.width);
+          animation.from.push_back(copy_rect.height);
+          break;
+        case Animation::SIZE:
+          animation.from.push_back(size.x);
+          animation.from.push_back(size.y);
+          animation.from.push_back(size.z);
+          break;
+        case Animation::TRANSLATION:
+          animation.from.push_back(translation.x);
+          animation.from.push_back(translation.y);
+          animation.from.push_back(translation.z);
+          break;
+        case Animation::ROTATION:
+          animation.from.push_back(rotation_axis_angle[0]);
+          animation.from.push_back(rotation_axis_angle[1]);
+          animation.from.push_back(rotation_axis_angle[2]);
+          animation.from.push_back(rotation_axis_angle[3]);
+          break;
+        case Animation::UNUSED:
+          break;
+      }
+    }
+    DCHECK_EQ(animation.from.size(), animation.to.size());
+
+    std::vector<float> values(animation.from.size());
+    for (std::size_t i = 0; i < animation.from.size(); ++i) {
+      if (animation.to[i] == animation.from[i] ||
+          time >= (animation.start + animation.duration)) {
+        values[i] = animation.to[i];
+        continue;
+      }
+      double value = animation.easing->CalculateValue(
+          (double)(time - animation.start) / (double)animation.duration);
+      values[i] =
+          animation.from[i] + (value * (animation.to[i] - animation.from[i]));
+    }
+    switch (animation.property) {
+      case Animation::COPYRECT:
+        DCHECK_EQ(animation.from.size(), 4u);
+        copy_rect.x = values[0];
+        copy_rect.y = values[1];
+        copy_rect.width = values[2];
+        copy_rect.height = values[3];
+        break;
+      case Animation::SIZE:
+        DCHECK_EQ(animation.from.size(), 3u);
+        size.x = values[0];
+        size.y = values[1];
+        size.z = values[2];
+        break;
+      case Animation::TRANSLATION:
+        DCHECK_EQ(animation.from.size(), 3u);
+        translation.x = values[0];
+        translation.y = values[1];
+        translation.z = values[2];
+        break;
+      case Animation::ROTATION:
+        DCHECK_EQ(animation.from.size(), 4u);
+        rotation_axis_angle[0] = values[0];
+        rotation_axis_angle[1] = values[1];
+        rotation_axis_angle[2] = values[2];
+        rotation_axis_angle[3] = values[3];
+        break;
+      case Animation::UNUSED:
+        break;
+    }
+  }
+  for (auto it = animations.begin(); it != animations.end();) {
+    const Animation& animation = **it;
+    if (time >= (animation.start + animation.duration)) {
+      it = animations.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace vr_shell