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 583 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().IsIdentity())
       transform->ConcatTransform(p->transform());
-    transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
-                               static_cast<float>(p->bounds().y()));
+    transform->ConcatTransform(translation);
   }
   return p == ancestor;
 }
 
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   if (bounds == bounds_)
     return;
 
   base::Closure closure;
   if (delegate_)
@@ skipping 141 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);
   cc_layer_->setTransform(WebKit::WebTransformationMatrix(transform));
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   if (!cc_layer_is_accelerated_) {
     cc_layer_->setBounds(ConvertSizeToPixel(this, bounds_.size()));
   } else {
     DCHECK(texture_);
 
     float texture_scale_factor = 1.0f / texture_->device_scale_factor();
     gfx::Size texture_size = gfx::ToFlooredSize(
         gfx::ScaleSize(texture_->size(), texture_scale_factor));
 
     gfx::Size size(std::min(bounds().width(), texture_size.width()),
                    std::min(bounds().height(), texture_size.height()));
     gfx::RectF rect(
         0,
         0,
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUVRect(rect);
 
     cc_layer_->setBounds(ConvertSizeToPixel(this, size));
   }
 }
 
 }  // namespace ui