Add support for inverse transform animations.

ui/compositor/transform_animation_curve_adapter_unittest.cc

Index: ui/compositor/transform_animation_curve_adapter_unittest.cc
diff --git a/ui/compositor/transform_animation_curve_adapter_unittest.cc b/ui/compositor/transform_animation_curve_adapter_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..99a8798f9403d0ca03b35031372e20bac483f36f
--- /dev/null
+++ b/ui/compositor/transform_animation_curve_adapter_unittest.cc
@@ -0,0 +1,59 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/compositor/transform_animation_curve_adapter.h"
+
+#include <sstream>
+
+#include "base/time/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/compositor/test/test_utils.h"
+
+namespace ui {
+
+namespace {
+
+// Check that the inverse transform curve gives the gives a transform that when
+// applied on top of the parent transform gives the original transform
+TEST(InverseTransformCurveAdapterTest, InversesTransform) {
+  gfx::Transform parent_start, parent_target;
+  parent_start.Scale(0.5, 3.0);
+  parent_start.Translate(-20.0, 30.0);
+  parent_target.Translate(0, 100);
+
+  gfx::Transform child_transform;
+  child_transform.Rotate(-30.0);
+
+  base::TimeDelta duration = base::TimeDelta::FromSeconds(1);
+
+  const gfx::Transform kEffective_child_transform =

[Ian Vollick, 2013/08/30 17:20:43]

nit: Since this isn't a compile-time constant, no need for the 'k' prefix. (That
said, if you do prefix a constant with k, you have to switch the whole thing to
camel case and ditch the hacker style underscores).

[danakj, 2013/08/30 17:21:37]

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Consta...

Style guide for reference. I've been applying that to all use of "const" it it
really should just be for things that are const at compile time. (thanks ian for
pointing this out.)

[avallee, 2013/09/04 15:04:41]

Done.

+      parent_start * child_transform;
+
+  TransformAnimationCurveAdapter parent_curve(Tween::LINEAR,
+                                              parent_start,
+                                              parent_target,
+                                              duration);
+
+  InverseTransformCurveAdapter child_curve(parent_curve,
+                                           child_transform,
+                                           duration);
+  const int kSteps = 1000;
+  double step = 1.0 / kSteps;
+  for (int i = 0; i != kSteps + 1; ++i) {
+    std::ostringstream message;
+    message << "Step " << i << " of " << kSteps;
+    SCOPED_TRACE(message.str());
+    gfx::Transform progress_parent_transform =
+            parent_curve.GetValue(i*step);
+    gfx::Transform progress_child_transform =
+            child_curve.GetValue(i*step);
+    CheckApproximatelyEqual(kEffective_child_transform,
+                            progress_parent_transform *
+                            progress_child_transform);
+  }
+}
+
+} // namespace
+
+} // namespace ui