Use SkMatrix44 for the underlying implementation of ui::Transform

ui/gfx/compositor/layer_animator.cc

 // Copyright (c) 2011 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/gfx/compositor/layer_animator.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/rect.h"
 
+namespace {
+
+void SetMatrixElement(SkMatrix44& matrix, int index, SkMScalar value) {
+  int row = index / 4;
+  int col = index % 4;
+  matrix.set(row, col, value);
+}
+
+SkMScalar GetMatrixElement(const SkMatrix44& matrix, int index) {
+  int row = index / 4;
+  int col = index % 4;
+  return matrix.get(row, col);
+}
+
+} // anonymous namespace
+
 namespace ui {
 
 LayerAnimator::LayerAnimator(Layer* layer)
     : layer_(layer),
       duration_in_ms_(200),
       animation_type_(ui::Tween::EASE_IN) {
 }
 
 LayerAnimator::~LayerAnimator() {
   for (Elements::iterator i = elements_.begin(); i != elements_.end(); ++i)
@@ skipping 18 matching lines @@
   element.params.location.start_x = layer_bounds.origin().x();
   element.params.location.start_y = layer_bounds.origin().y();
   element.params.location.target_x = target.x();
   element.params.location.target_y = target.y();
   element.animation = CreateAndStartAnimation();
 }
 
 void LayerAnimator::AnimateTransform(const Transform& transform) {
   StopAnimating(TRANSFORM);
   const Transform& layer_transform = layer_->transform();
-  bool all_equal = true;
-  // TODO: replace with == when we Transform supports ==.
-  for (int i = 0; i < 9; ++i) {
-    if (transform.matrix()[i] != layer_transform.matrix()[i]) {
-      all_equal = false;
-      break;
-    }
-  }
-  if (all_equal)
+  if (transform == layer_transform)
     return;  // Already there.
 
   Element& element = elements_[TRANSFORM];
-  for (int i = 0; i < 9; ++i) {
-    element.params.transform.start[i] = layer_transform.matrix()[i];
-    element.params.transform.target[i] = transform.matrix()[i];
+  for (int i = 0; i < 16; ++i) {
+    element.params.transform.start[i] =
+      GetMatrixElement(layer_transform.matrix(), i);
+    element.params.transform.target[i] =
+      GetMatrixElement(transform.matrix(), i);
   }
   element.animation = CreateAndStartAnimation();
 }
 
 void LayerAnimator::AnimationProgressed(const ui::Animation* animation) {
   Elements::iterator e = GetElementByAnimation(
       static_cast<const ui::MultiAnimation*>(animation));
   DCHECK(e != elements_.end());
   switch (e->first) {
     case LOCATION: {
       const gfx::Rect& current_bounds(layer_->bounds());
       gfx::Rect new_bounds = e->second.animation->CurrentValueBetween(
           gfx::Rect(gfx::Point(e->second.params.location.start_x,
                                e->second.params.location.start_y),
                     current_bounds.size()),
           gfx::Rect(gfx::Point(e->second.params.location.target_x,
                                e->second.params.location.target_y),
                     current_bounds.size()));
       layer_->set_bounds(new_bounds);
       break;
     }
 
     case TRANSFORM: {
       Transform transform;
-      for (int i = 0; i < 9; ++i) {
-        transform.matrix()[i] = e->second.animation->CurrentValueBetween(
-            e->second.params.transform.start[i],
-            e->second.params.transform.target[i]);
+      for (int i = 0; i < 16; ++i) {
+        SkMScalar value = e->second.animation->CurrentValueBetween(
+          e->second.params.transform.start[i],
+          e->second.params.transform.target[i]);
+        SetMatrixElement(transform.matrix(), i, value);
       }
       layer_->set_transform(transform);
       break;
     }
 
     default:
       NOTREACHED();
   }
   layer_->compositor()->SchedulePaint();
 }
 
 void LayerAnimator::AnimationEnded(const ui::Animation* animation) {
   Elements::iterator e = GetElementByAnimation(
       static_cast<const ui::MultiAnimation*>(animation));
   DCHECK(e != elements_.end());
   switch (e->first) {
     case LOCATION: {
       gfx::Rect new_bounds(
           gfx::Point(e->second.params.location.target_x,
                      e->second.params.location.target_y),
           layer_->bounds().size());
       layer_->set_bounds(new_bounds);
       break;
     }
 
     case TRANSFORM: {
       Transform transform;
-      for (int i = 0; i < 9; ++i)
-        transform.matrix()[i] = e->second.params.transform.target[i];
+      for (int i = 0; i < 16; ++i) {
+        SetMatrixElement(transform.matrix(),
+                         i,
+                         e->second.params.transform.target[i]);
+      }
       layer_->set_transform(transform);
       break;
     }
 
     default:
       NOTREACHED();
   }
   StopAnimating(e->first);
   // StopAnimating removes from the map, invalidating 'e'.
   e = elements_.end();
@@ skipping 30 matching lines @@
     const ui::MultiAnimation* animation) {
   for (Elements::iterator i = elements_.begin(); i != elements_.end(); ++i) {
     if (i->second.animation == animation)
       return i;
   }
   NOTREACHED();
   return elements_.end();
 }
 
 }  // namespace ui