Add support for inverse transform animations.

ui/compositor/transform_animation_curve_adapter_unittest.cc

+// 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 effective_child_transform =
+      parent_start * child_transform;
+
+  TransformAnimationCurveAdapter parent_curve(Tween::LINEAR,
+                                              parent_start,
+                                              parent_target,
+                                              duration);
+
+  InverseTransformCurveAdapter child_curve(parent_curve,
+                                           child_transform,
+                                           duration);
+  static const int kSteps = 1000;
+  double step = 1.0 / kSteps;
+  for (int i = 0; i != kSteps + 1; ++i) {

[danakj, 2013/09/04 15:29:09]

nit: i < kSteps + 1 ?

[avallee, 2013/09/04 15:36:53]

I want to exit the loop having done 1001 steps in this case, with i in the
interval [0-1000]. At the end of the loop i == 1001, the number of steps taken.

[danakj, 2013/09/04 15:47:40]

I'm not sure how < and != differ in this case. They both exit when i == kSteps +
1, don't they? But < is much more commonly seen and easier to understand.

[danakj, 2013/09/04 15:48:26]

(i <= kSteps) would also work if you preferred.

[avallee, 2013/09/04 15:50:34]

Done.

+    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(effective_child_transform,
+                            progress_parent_transform *
+                            progress_child_transform);
+  }
+}
+
+} // namespace
+
+} // namespace ui