gfx::Transform API clean-up

ui/compositor/layer.cc

 // Copyright (c) 2012 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/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 597 matching lines @@
   gfx::Point3F p(*point);
   transform.TransformPointReverse(p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
 
 bool Layer::GetTransformRelativeTo(const Layer* ancestor,
                                    gfx::Transform* transform) const {
   const Layer* p = this;
   for (; p && p != ancestor; p = p->parent()) {
+    gfx::Transform translation;
+    translation.Translate(static_cast<float>(p->bounds().x()),
+                          static_cast<float>(p->bounds().y()));
     if (p->transform().HasChange())
-      transform->ConcatTransform(p->transform());
-    transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
-                               static_cast<float>(p->bounds().y()));
+      *transform = translation * p->transform() * *transform;
+    else
+      *transform = translation * *transform;
   }
   return p == ancestor;
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
 
   base::Closure closure;
   if (delegate_)
@@ skipping 142 matching lines @@
   gfx::Transform scale_translate;
   scale_translate.matrix().set3x3(device_scale_factor_, 0, 0,
                                   0, device_scale_factor_, 0,
                                   0, 0, 1);
   // Start with the inverse matrix of above.
   gfx::Transform transform;
   transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
                             0, 1.0f / device_scale_factor_, 0,
                             0, 0, 1);
   transform.ConcatTransform(transform_);
-  transform.ConcatTranslate(bounds_.x(), bounds_.y());
+  gfx::Transform translate;
+  translate.Translate(bounds_.x(), bounds_.y());
+  transform.ConcatTransform(translate);
   transform.ConcatTransform(scale_translate);
   web_layer_->setTransform(transform.matrix());
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(web_layer_);
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
     if (type_ != LAYER_SOLID_COLOR) {
       web_layer_->setDrawsContent(should_draw);
@@ skipping 14 matching lines @@
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUVRect(rect);
 
     gfx::Size size_in_pixel = ConvertSizeToPixel(this, size);
     web_layer_->setBounds(size_in_pixel);
   }
 }
 
 }  // namespace ui