Rename Layer::screen_space_transform to Layer::ScreenSpaceTransform

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp

 // Copyright 2016 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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include <memory>
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 149 matching lines @@
   TestPaintArtifact artifact;
   artifact.Chunk(DefaultPaintChunkProperties())
       .RectDrawing(FloatRect(50, -50, 100, 100), Color::kWhite);
   Update(artifact.Build());
 
   ASSERT_EQ(1u, ContentLayerCount());
   const cc::Layer* child = ContentLayerAt(0);
   EXPECT_THAT(
       child->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kWhite)));
-  EXPECT_EQ(Translation(50, -50), child->screen_space_transform());
+  EXPECT_EQ(Translation(50, -50), child->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Size(100, 100), child->bounds());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneTransform) {
   // A 90 degree clockwise rotation about (100, 100).
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::Create(
           TransformPaintPropertyNode::Root(), TransformationMatrix().Rotate(90),
           FloatPoint3D(100, 100, 0), false, 0, kCompositingReason3DTransform);
 
@@ skipping 18 matching lines @@
 
     Vector<RectWithColor> rects_with_color;
     rects_with_color.push_back(
         RectWithColor(FloatRect(0, 0, 100, 100), Color::kWhite));
     rects_with_color.push_back(
         RectWithColor(FloatRect(100, 100, 200, 100), Color::kBlack));
 
     EXPECT_THAT(layer->GetPicture(),
                 Pointee(DrawsRectangles(rects_with_color)));
     gfx::RectF mapped_rect(0, 0, 100, 100);
-    layer->screen_space_transform().TransformRect(&mapped_rect);
+    layer->ScreenSpaceTransform().TransformRect(&mapped_rect);
     EXPECT_EQ(gfx::RectF(100, 0, 100, 100), mapped_rect);
   }
   {
     const cc::Layer* layer = ContentLayerAt(1);
     EXPECT_THAT(
         layer->GetPicture(),
         Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kGray)));
-    EXPECT_EQ(gfx::Transform(), layer->screen_space_transform());
+    EXPECT_EQ(gfx::Transform(), layer->ScreenSpaceTransform());
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformCombining) {
   // A translation by (5, 5) within a 2x scale about (10, 10).
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::Create(
           TransformPaintPropertyNode::Root(), TransformationMatrix().Scale(2),
           FloatPoint3D(10, 10, 0), false, 0, kCompositingReason3DTransform);
   RefPtr<TransformPaintPropertyNode> transform2 =
@@ skipping 12 matching lines @@
       .RectDrawing(FloatRect(0, 0, 300, 200), Color::kBlack);
   Update(artifact.Build());
 
   ASSERT_EQ(2u, ContentLayerCount());
   {
     const cc::Layer* layer = ContentLayerAt(0);
     EXPECT_THAT(
         layer->GetPicture(),
         Pointee(DrawsRectangle(FloatRect(0, 0, 300, 200), Color::kWhite)));
     gfx::RectF mapped_rect(0, 0, 300, 200);
-    layer->screen_space_transform().TransformRect(&mapped_rect);
+    layer->ScreenSpaceTransform().TransformRect(&mapped_rect);
     EXPECT_EQ(gfx::RectF(-10, -10, 600, 400), mapped_rect);
   }
   {
     const cc::Layer* layer = ContentLayerAt(1);
     EXPECT_THAT(
         layer->GetPicture(),
         Pointee(DrawsRectangle(FloatRect(0, 0, 300, 200), Color::kBlack)));
     gfx::RectF mapped_rect(0, 0, 300, 200);
-    layer->screen_space_transform().TransformRect(&mapped_rect);
+    layer->ScreenSpaceTransform().TransformRect(&mapped_rect);
     EXPECT_EQ(gfx::RectF(0, 0, 600, 400), mapped_rect);
   }
   EXPECT_NE(ContentLayerAt(0)->transform_tree_index(),
             ContentLayerAt(1)->transform_tree_index());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        FlattensInheritedTransform) {
   for (bool transform_is_flattened : {true, false}) {
     SCOPED_TRACE(transform_is_flattened);
@@ skipping 36 matching lines @@
     EXPECT_EQ(transform_is_flattened,
               transform_node3->flattens_inherited_transform);
 
     // Given this, we should expect the correct screen space transform for
     // each case. If the transform was flattened, we should see it getting
     // an effective horizontal scale of 1/sqrt(2) each time, thus it gets
     // half as wide. If the transform was not flattened, we should see an
     // empty rectangle (as the total 90 degree rotation makes it
     // perpendicular to the viewport).
     gfx::RectF rect(0, 0, 100, 100);
-    layer->screen_space_transform().TransformRect(&rect);
+    layer->ScreenSpaceTransform().TransformRect(&rect);
     if (transform_is_flattened)
       EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 100), rect);
     else
       EXPECT_TRUE(rect.IsEmpty());
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SortingContextID) {
   // Has no 3D rendering context.
   RefPtr<TransformPaintPropertyNode> transform1 =
@@ skipping 90 matching lines @@
       .Chunk(TransformPaintPropertyNode::Root(), clip,
              EffectPaintPropertyNode::Root())
       .RectDrawing(FloatRect(220, 80, 300, 200), Color::kBlack);
   Update(artifact.Build());
 
   ASSERT_EQ(1u, ContentLayerCount());
   const cc::Layer* layer = ContentLayerAt(0);
   EXPECT_THAT(
       layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 300, 200), Color::kBlack)));
-  EXPECT_EQ(Translation(220, 80), layer->screen_space_transform());
+  EXPECT_EQ(Translation(220, 80), layer->ScreenSpaceTransform());
 
   const cc::ClipNode* clip_node =
       GetPropertyTrees().clip_tree.Node(layer->clip_tree_index());
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, clip_node->clip_type);
   EXPECT_EQ(gfx::RectF(100, 100, 300, 200), clip_node->clip);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, NestedClips) {
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::Create(
       ClipPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
@@ skipping 22 matching lines @@
              EffectPaintPropertyNode::Root())
       .RectDrawing(FloatRect(300, 350, 100, 100), Color::kBlack);
   Update(artifact.Build());
 
   ASSERT_EQ(4u, ContentLayerCount());
 
   const cc::Layer* white_layer = ContentLayerAt(0);
   EXPECT_THAT(
       white_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kWhite)));
-  EXPECT_EQ(Translation(300, 350), white_layer->screen_space_transform());
+  EXPECT_EQ(Translation(300, 350), white_layer->ScreenSpaceTransform());
 
   const cc::Layer* light_gray_layer = ContentLayerAt(1);
   EXPECT_THAT(
       light_gray_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kLightGray)));
-  EXPECT_EQ(Translation(300, 350), light_gray_layer->screen_space_transform());
+  EXPECT_EQ(Translation(300, 350), light_gray_layer->ScreenSpaceTransform());
 
   const cc::Layer* dark_gray_layer = ContentLayerAt(2);
   EXPECT_THAT(
       dark_gray_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kDarkGray)));
-  EXPECT_EQ(Translation(300, 350), dark_gray_layer->screen_space_transform());
+  EXPECT_EQ(Translation(300, 350), dark_gray_layer->ScreenSpaceTransform());
 
   const cc::Layer* black_layer = ContentLayerAt(3);
   EXPECT_THAT(
       black_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kBlack)));
-  EXPECT_EQ(Translation(300, 350), black_layer->screen_space_transform());
+  EXPECT_EQ(Translation(300, 350), black_layer->ScreenSpaceTransform());
 
   EXPECT_EQ(white_layer->clip_tree_index(), dark_gray_layer->clip_tree_index());
   const cc::ClipNode* outer_clip =
       GetPropertyTrees().clip_tree.Node(white_layer->clip_tree_index());
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, outer_clip->clip_type);
   EXPECT_EQ(gfx::RectF(100, 100, 700, 700), outer_clip->clip);
 
   EXPECT_EQ(light_gray_layer->clip_tree_index(),
             black_layer->clip_tree_index());
   const cc::ClipNode* inner_clip =
@@ skipping 18 matching lines @@
              EffectPaintPropertyNode::Root())
       .RectDrawing(FloatRect(0, 0, 200, 200), Color::kWhite);
   Update(artifact.Build());
 
   // Check the drawing layer.
   ASSERT_EQ(1u, ContentLayerCount());
   const cc::Layer* drawing_layer = ContentLayerAt(0);
   EXPECT_THAT(
       drawing_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 200, 200), Color::kWhite)));
-  EXPECT_EQ(gfx::Transform(), drawing_layer->screen_space_transform());
+  EXPECT_EQ(gfx::Transform(), drawing_layer->ScreenSpaceTransform());
 
   // Check the clip nodes.
   const cc::ClipNode* clip_node =
       GetPropertyTrees().clip_tree.Node(drawing_layer->clip_tree_index());
   for (auto it = clips.rbegin(); it != clips.rend(); ++it) {
     const ClipPaintPropertyNode* paint_clip_node = it->Get();
     EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, clip_node->clip_type);
     EXPECT_EQ(paint_clip_node->ClipRect().Rect(), clip_node->clip);
     clip_node = GetPropertyTrees().clip_tree.Node(clip_node->parent_id);
   }
@@ skipping 19 matching lines @@
       .Chunk(TransformPaintPropertyNode::Root(), clip2,
              EffectPaintPropertyNode::Root())
       .RectDrawing(FloatRect(0, 0, 640, 480), Color::kBlack);
   Update(artifact.Build());
   ASSERT_EQ(2u, ContentLayerCount());
 
   const cc::Layer* white_layer = ContentLayerAt(0);
   EXPECT_THAT(
       white_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 640, 480), Color::kWhite)));
-  EXPECT_EQ(gfx::Transform(), white_layer->screen_space_transform());
+  EXPECT_EQ(gfx::Transform(), white_layer->ScreenSpaceTransform());
   const cc::ClipNode* white_clip =
       GetPropertyTrees().clip_tree.Node(white_layer->clip_tree_index());
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, white_clip->clip_type);
   ASSERT_EQ(gfx::RectF(0, 0, 400, 600), white_clip->clip);
 
   const cc::Layer* black_layer = ContentLayerAt(1);
   EXPECT_THAT(
       black_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 640, 480), Color::kBlack)));
-  EXPECT_EQ(gfx::Transform(), black_layer->screen_space_transform());
+  EXPECT_EQ(gfx::Transform(), black_layer->ScreenSpaceTransform());
   const cc::ClipNode* black_clip =
       GetPropertyTrees().clip_tree.Node(black_layer->clip_tree_index());
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, black_clip->clip_type);
   ASSERT_EQ(gfx::RectF(400, 0, 400, 600), black_clip->clip);
 
   EXPECT_EQ(white_clip->parent_id, black_clip->parent_id);
   const cc::ClipNode* common_clip_node =
       GetPropertyTrees().clip_tree.Node(white_clip->parent_id);
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP,
             common_clip_node->clip_type);
@@ skipping 16 matching lines @@
              EffectPaintPropertyNode::Root())
       .RectDrawing(FloatRect(0, 0, 100, 100), Color::kGray);
 
   const PaintArtifact& artifact = test_artifact.Build();
   ASSERT_EQ(3u, artifact.PaintChunks().size());
   Update(artifact);
 
   ASSERT_EQ(3u, ContentLayerCount());
   EXPECT_EQ(layer, ContentLayerAt(1));
   EXPECT_EQ(gfx::Size(400, 300), layer->bounds());
-  EXPECT_EQ(Translation(50, 60), layer->screen_space_transform());
+  EXPECT_EQ(Translation(50, 60), layer->ScreenSpaceTransform());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectTreeConversion) {
   RefPtr<EffectPaintPropertyNode> effect1 = EffectPaintPropertyNode::Create(
       EffectPaintPropertyNode::Root(), TransformPaintPropertyNode::Root(),
       ClipPaintPropertyNode::Root(), kColorFilterNone,
       CompositorFilterOperations(), 0.5, SkBlendMode::kSrcOver,
       kCompositingReasonAll);
   RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::Create(
       effect1, TransformPaintPropertyNode::Root(),
@@ skipping 1087 matching lines @@
   artifact
       .Chunk(TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
              masking.Get())
       .RectDrawing(FloatRect(150, 150, 100, 100), Color::kWhite);
   Update(artifact.Build());
   ASSERT_EQ(2u, ContentLayerCount());
 
   const cc::Layer* masked_layer = ContentLayerAt(0);
   EXPECT_THAT(masked_layer->GetPicture(),
               Pointee(DrawsRectangle(FloatRect(0, 0, 200, 200), Color::kGray)));
-  EXPECT_EQ(Translation(100, 100), masked_layer->screen_space_transform());
+  EXPECT_EQ(Translation(100, 100), masked_layer->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Size(200, 200), masked_layer->bounds());
   const cc::EffectNode* masked_group =
       GetPropertyTrees().effect_tree.Node(masked_layer->effect_tree_index());
   EXPECT_TRUE(masked_group->has_render_surface);
 
   const cc::Layer* masking_layer = ContentLayerAt(1);
   EXPECT_THAT(
       masking_layer->GetPicture(),
       Pointee(DrawsRectangle(FloatRect(0, 0, 100, 100), Color::kWhite)));
-  EXPECT_EQ(Translation(150, 150), masking_layer->screen_space_transform());
+  EXPECT_EQ(Translation(150, 150), masking_layer->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Size(100, 100), masking_layer->bounds());
   const cc::EffectNode* masking_group =
       GetPropertyTrees().effect_tree.Node(masking_layer->effect_tree_index());
   EXPECT_TRUE(masking_group->has_render_surface);
   EXPECT_EQ(masked_group->id, masking_group->parent_id);
   ASSERT_EQ(1u, masking_group->filters.size());
   EXPECT_EQ(cc::FilterOperation::REFERENCE,
             masking_group->filters.at(0).type());
 }
 
@@ skipping 326 matching lines @@
   Update(artifact.Build(), composited_element_ids);
 
   EXPECT_EQ(2u, composited_element_ids.size());
   EXPECT_TRUE(
       composited_element_ids.Contains(transform->GetCompositorElementId()));
   EXPECT_TRUE(
       composited_element_ids.Contains(effect->GetCompositorElementId()));
 }
 
 }  // namespace blink