gfx::Transform API clean-up

ui/views/view_unittest.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 <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 2039 matching lines @@
 
   // At this moment, |v2| occupies (100, 100) to (300, 200) in |root|.
   v1->ClearScheduledPaintRect();
   v2->SchedulePaint();
 
   EXPECT_EQ(gfx::Rect(100, 100, 200, 100), v1->scheduled_paint_rect());
 
   // Rotate |v1| counter-clockwise.
   gfx::Transform transform;
   RotateCounterclockwise(&transform);
-  transform.SetTranslateY(500.0f);
+  transform.matrix().set(1, 3, 500.0);
   v1->SetTransform(transform);
 
   // |v2| now occupies (100, 200) to (200, 400) in |root|.
 
   v1->ClearScheduledPaintRect();
   v2->SchedulePaint();
 
   EXPECT_EQ(gfx::Rect(100, 200, 100, 200), v1->scheduled_paint_rect());
 
   widget->CloseNow();
@@ skipping 13 matching lines @@
   View* root = widget->GetRootView();
 
   root->AddChildView(v1);
   v1->AddChildView(v2);
 
   // At this moment, |v2| occupies (100, 100) to (300, 200) in |root|.
 
   // Rotate |v1| counter-clockwise.
   gfx::Transform transform(v1->GetTransform());
   RotateCounterclockwise(&transform);
-  transform.SetTranslateY(500.0f);
+  transform.matrix().set(1, 3, 500.0);
   v1->SetTransform(transform);
 
   // |v2| now occupies (100, 200) to (200, 400) in |root|.
   v1->Reset();
   v2->Reset();
 
   gfx::Point p1(110, 210);
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, p1, p1,
                          ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(pressed);
   EXPECT_EQ(0, v1->last_mouse_event_type_);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v2->last_mouse_event_type_);
   EXPECT_EQ(190, v2->location_.x());
   EXPECT_EQ(10, v2->location_.y());
 
   ui::MouseEvent released(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), 0);
   root->OnMouseReleased(released);
 
   // Now rotate |v2| inside |v1| clockwise.
   transform = v2->GetTransform();
   RotateClockwise(&transform);
-  transform.SetTranslateX(100.0f);
+  transform.matrix().setDouble(0, 3, 100.0);
   v2->SetTransform(transform);
 
   // Now, |v2| occupies (100, 100) to (200, 300) in |v1|, and (100, 300) to
   // (300, 400) in |root|.
 
   v1->Reset();
   v2->Reset();
 
   gfx::Point point2(110, 320);
   ui::MouseEvent p2(ui::ET_MOUSE_PRESSED, point2, point2,
                     ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(p2);
   EXPECT_EQ(0, v1->last_mouse_event_type_);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v2->last_mouse_event_type_);
   EXPECT_EQ(10, v2->location_.x());
   EXPECT_EQ(20, v2->location_.y());
 
   root->OnMouseReleased(released);
 
   v1->SetTransform(gfx::Transform());
   v2->SetTransform(gfx::Transform());
 
   TestView* v3 = new TestView();
   v3->SetBoundsRect(gfx::Rect(10, 10, 20, 30));
   v2->AddChildView(v3);
 
   // Rotate |v3| clockwise with respect to |v2|.
   transform = v1->GetTransform();
   RotateClockwise(&transform);
-  transform.SetTranslateX(30.0f);
+  transform.matrix().setDouble(0, 3, 30.0);
   v3->SetTransform(transform);
 
   // Scale |v2| with respect to |v1| along both axis.
   transform = v2->GetTransform();
-  transform.SetScale(0.8f, 0.5f);
+  transform.matrix().setDouble(0, 0, 0.8);
+  transform.matrix().setDouble(1, 1, 0.5);
   v2->SetTransform(transform);
 
   // |v3| occupies (108, 105) to (132, 115) in |root|.
 
   v1->Reset();
   v2->Reset();
   v3->Reset();
 
   gfx::Point point(112, 110);
   ui::MouseEvent p3(ui::ET_MOUSE_PRESSED, point, point,
@@ skipping 10 matching lines @@
   v2->SetTransform(gfx::Transform());
   v3->SetTransform(gfx::Transform());
 
   v1->Reset();
   v2->Reset();
   v3->Reset();
 
   // Rotate |v3| clockwise with respect to |v2|, and scale it along both axis.
   transform = v3->GetTransform();
   RotateClockwise(&transform);
-  transform.SetTranslateX(30.0f);
+  transform.matrix().setDouble(0, 3, 30.0);
   // Rotation sets some scaling transformation. Using SetScale would overwrite
   // that and pollute the rotation. So combine the scaling with the existing
   // transforamtion.
-  transform.ConcatScale(0.8f, 0.5f);
+  gfx::Transform scale;
+  scale.Scale(0.8, 0.5);
+  transform.ConcatTransform(scale);
   v3->SetTransform(transform);
 
   // Translate |v2| with respect to |v1|.
   transform = v2->GetTransform();
-  transform.SetTranslate(10, 10);
+  transform.matrix().setDouble(0, 3, 10.0);
+  transform.matrix().setDouble(1, 3, 10.0);
   v2->SetTransform(transform);
 
   // |v3| now occupies (120, 120) to (144, 130) in |root|.
 
   gfx::Point point3(124, 125);
   ui::MouseEvent p4(ui::ET_MOUSE_PRESSED, point3, point3,
                     ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(p4);
 
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v3->last_mouse_event_type_);
@@ skipping 23 matching lines @@
   contents->SetBoundsRect(gfx::Rect(0, 0, 100, 200));
 
   View* child = new View;
   contents->AddChildView(child);
   child->SetBoundsRect(gfx::Rect(10, 90, 50, 50));
   EXPECT_EQ(gfx::Rect(0, 0, 50, 10), child->GetVisibleBounds());
 
   // Rotate |child| counter-clockwise
   gfx::Transform transform;
   RotateCounterclockwise(&transform);
-  transform.SetTranslateY(50.0f);
+  transform.matrix().setDouble(1, 3, 50.0);
   child->SetTransform(transform);
   EXPECT_EQ(gfx::Rect(40, 0, 10, 50), child->GetVisibleBounds());
 
   widget->CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OnVisibleBoundsChanged()
 
 class VisibleBoundsView : public View {
@@ skipping 93 matching lines @@
   TestView* child = new TestView;
   TestView* child_child = new TestView;
 
   top_view.AddChildView(child);
   child->AddChildView(child_child);
 
   top_view.SetBoundsRect(gfx::Rect(0, 0, 1000, 1000));
 
   child->SetBoundsRect(gfx::Rect(7, 19, 500, 500));
   gfx::Transform transform;
-  transform.SetScale(3.0f, 4.0f);
+  transform.Scale(3.0, 4.0);
   child->SetTransform(transform);
 
   child_child->SetBoundsRect(gfx::Rect(17, 13, 100, 100));
-  transform = gfx::Transform();
-  transform.SetScale(5.0f, 7.0f);
+  transform.MakeIdentity();
+  transform.Scale(5.0, 7.0);
   child_child->SetTransform(transform);
 
   // Sanity check to make sure basic transforms act as expected.
   {
     gfx::Transform transform;
-    transform.ConcatTranslate(1, 1);
-    transform.ConcatScale(100, 55);
-    transform.ConcatTranslate(110, -110);
+    transform.Translate(110.0, -110.0);
+    transform.Scale(100.0, 55.0);
+    transform.Translate(1.0, 1.0);
 
     // convert to a 3x3 matrix.
     const SkMatrix& matrix = transform.matrix();
 
     EXPECT_EQ(210, matrix.getTranslateX());
     EXPECT_EQ(-55, matrix.getTranslateY());
     EXPECT_EQ(100, matrix.getScaleX());
     EXPECT_EQ(55, matrix.getScaleY());
     EXPECT_EQ(0, matrix.getSkewX());
     EXPECT_EQ(0, matrix.getSkewY());
   }
 
   {
     gfx::Transform transform;
-    transform.SetTranslate(1, 1);
+    transform.Translate(1.0, 1.0);
     gfx::Transform t2;
-    t2.SetScale(100, 55);
+    t2.Scale(100.0, 55.0);
     gfx::Transform t3;
-    t3.SetTranslate(110, -110);
+    t3.Translate(110.0, -110.0);
     transform.ConcatTransform(t2);
     transform.ConcatTransform(t3);
 
     // convert to a 3x3 matrix
     const SkMatrix& matrix = transform.matrix();
 
     EXPECT_EQ(210, matrix.getTranslateX());
     EXPECT_EQ(-55, matrix.getTranslateY());
     EXPECT_EQ(100, matrix.getScaleX());
     EXPECT_EQ(55, matrix.getScaleY());
@@ skipping 68 matching lines @@
   v2->SetBoundsRect(gfx::Rect(20, 20, 100, 200));
 
   // |v2| now occupies (30, 30) to (130, 230) in |widget|
   gfx::Rect rect(5, 5, 15, 40);
   EXPECT_EQ(gfx::Rect(25, 25, 15, 40), v2->ConvertRectToParent(rect));
   EXPECT_EQ(gfx::Rect(35, 35, 15, 40), v2->ConvertRectToWidget(rect));
 
   // Rotate |v2|
   gfx::Transform t2;
   RotateCounterclockwise(&t2);
-  t2.SetTranslateY(100.0f);
+  t2.matrix().setDouble(1, 3, 100.0);
   v2->SetTransform(t2);
 
   // |v2| now occupies (30, 30) to (230, 130) in |widget|
   EXPECT_EQ(gfx::Rect(25, 100, 40, 15), v2->ConvertRectToParent(rect));
   EXPECT_EQ(gfx::Rect(35, 110, 40, 15), v2->ConvertRectToWidget(rect));
 
   // Scale down |v1|
   gfx::Transform t1;
-  t1.SetScale(0.5, 0.5);
+  t1.Scale(0.5, 0.5);
   v1->SetTransform(t1);
 
   // The rectangle should remain the same for |v1|.
   EXPECT_EQ(gfx::Rect(25, 100, 40, 15), v2->ConvertRectToParent(rect));
 
   // |v2| now occupies (20, 20) to (120, 70) in |widget|
   EXPECT_EQ(gfx::Rect(22, 60, 21, 8).ToString(),
             v2->ConvertRectToWidget(rect).ToString());
 
   widget->CloseNow();
@@ skipping 483 matching lines @@
   EXPECT_TRUE(v2->layer() != NULL);
   EXPECT_EQ(root_layer, v2->layer()->parent());
   ASSERT_EQ(1u, root_layer->children().size());
   EXPECT_EQ(root_layer->children()[0], v2->layer());
   // The bounds of the layer should have changed to be relative to the root view
   // now.
   EXPECT_EQ(gfx::Rect(30, 50, 30, 40), v2->layer()->bounds());
 
   // Make v1 have a layer again and verify v2s layer is wired up correctly.
   gfx::Transform transform;
-  transform.SetScale(2.0f, 2.0f);
+  transform.Scale(2.0, 2.0);
   v1->SetTransform(transform);
   EXPECT_TRUE(v1->layer() != NULL);
   EXPECT_TRUE(v2->layer() != NULL);
   EXPECT_EQ(root_layer, v1->layer()->parent());
   EXPECT_EQ(v1->layer(), v2->layer()->parent());
   ASSERT_EQ(1u, root_layer->children().size());
   EXPECT_EQ(root_layer->children()[0], v1->layer());
   ASSERT_EQ(1u, v1->layer()->children().size());
   EXPECT_EQ(v1->layer()->children()[0], v2->layer());
   EXPECT_EQ(gfx::Rect(10, 20, 30, 40), v2->layer()->bounds());
@@ skipping 131 matching lines @@
   EXPECT_EQ(l2bounds, v2->layer()->bounds());
 
   // Reset locale.
   base::i18n::SetICUDefaultLocale(locale);
 }
 
 // Makes sure a transform persists after toggling the visibility.
 TEST_F(ViewLayerTest, ToggleVisibilityWithTransform) {
   View* view = new View;
   gfx::Transform transform;
-  transform.SetScale(2.0f, 2.0f);
+  transform.Scale(2.0, 2.0);
   view->SetTransform(transform);
   widget()->SetContentsView(view);
   EXPECT_EQ(2.0f, view->GetTransform().matrix().get(0, 0));
 
   view->SetVisible(false);
   EXPECT_EQ(2.0f, view->GetTransform().matrix().get(0, 0));
 
   view->SetVisible(true);
   EXPECT_EQ(2.0f, view->GetTransform().matrix().get(0, 0));
 }
 
 // Verifies a transform persists after removing/adding a view with a transform.
 TEST_F(ViewLayerTest, ResetTransformOnLayerAfterAdd) {
   View* view = new View;
   gfx::Transform transform;
-  transform.SetScale(2.0f, 2.0f);
+  transform.Scale(2.0, 2.0);
   view->SetTransform(transform);
   widget()->SetContentsView(view);
   EXPECT_EQ(2.0f, view->GetTransform().matrix().get(0, 0));
   ASSERT_TRUE(view->layer() != NULL);
   EXPECT_EQ(2.0f, view->layer()->transform().matrix().get(0, 0));
 
   View* parent = view->parent();
   parent->RemoveChildView(view);
   parent->AddChildView(view);
 
@@ skipping 224 matching lines @@
   // Set to non default value.
   v->layer()->set_scale_content(false);
   scoped_ptr<ui::Layer> old_layer(v->RecreateLayer());
   ui::Layer* new_layer = v->layer();
   EXPECT_FALSE(new_layer->scale_content());
 }
 
 #endif  // USE_AURA
 
 }  // namespace views