Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

cc/damage_tracker.cc

 // Copyright 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 "cc/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/render_surface_impl.h"
 #include <public/WebFilterOperations.h>
 
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;

[danakj, 2012/11/24 02:34:54]

don't using it, let's say gfx:: explicitly at each use, as we do for rect etc.

 
 namespace cc {
 
 scoped_ptr<DamageTracker> DamageTracker::create()
 {
     return make_scoped_ptr(new DamageTracker());
 }
 
 DamageTracker::DamageTracker()
     : m_forceFullDamageNextUpdate(false),
@@ skipping 275 matching lines @@
 
         // The surface's old region is now exposed on the target surface, too.
         targetDamageRect.Union(oldSurfaceRect);
     } else {
         // Only the surface's damageRect will damage the target surface.
         damageRectInLocalSpace = renderSurface->damageTracker()->currentDamageRect();
     }
 
     // If there was damage, transform it to target space, and possibly contribute its reflection if needed.
     if (!damageRectInLocalSpace.IsEmpty()) {
-        const WebTransformationMatrix& drawTransform = renderSurface->drawTransform();
+        const Transform& drawTransform = renderSurface->drawTransform();
         gfx::RectF damageRectInTargetSpace = MathUtil::mapClippedRect(drawTransform, damageRectInLocalSpace);
         targetDamageRect.Union(damageRectInTargetSpace);
 
         if (layer->replicaLayer()) {
-            const WebTransformationMatrix& replicaDrawTransform = renderSurface->replicaDrawTransform();
+            const Transform& replicaDrawTransform = renderSurface->replicaDrawTransform();
             targetDamageRect.Union(MathUtil::mapClippedRect(replicaDrawTransform, damageRectInLocalSpace));
         }
     }
 
     // If there was damage on the replica's mask, then the target surface receives that damage as well.
     if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
         LayerImpl* replicaMaskLayer = layer->replicaLayer()->maskLayer();
 
         bool replicaIsNew = false;
         removeRectFromCurrentFrame(replicaMaskLayer->id(), replicaIsNew);
 
-        const WebTransformationMatrix& replicaDrawTransform = renderSurface->replicaDrawTransform();
+        const Transform& replicaDrawTransform = renderSurface->replicaDrawTransform();
         gfx::RectF replicaMaskLayerRect = MathUtil::mapClippedRect(replicaDrawTransform, gfx::RectF(gfx::PointF(), replicaMaskLayer->bounds()));
         saveRectForNextFrame(replicaMaskLayer->id(), replicaMaskLayerRect);
 
         // In the current implementation, a change in the replica mask damages the entire replica region.
         if (replicaIsNew || replicaMaskLayer->layerPropertyChanged() || !replicaMaskLayer->updateRect().IsEmpty())
             targetDamageRect.Union(replicaMaskLayerRect);
     }
 
     // If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
     // at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
     // the contents of layers below this one in them. This means we need to redraw any pixels in the surface being used for the blur in
     // this layer this frame.
     if (layer->backgroundFilters().hasFilterThatMovesPixels())
         expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
 }
 
 }  // namespace cc