SkMatrix44 --> SkMatrix is now explicit

Note: SkCanvas now stores a 4x4 internally in its matrix stack...

Change-Id: I13ea2702b764d46a11821344dabcef58b58909ba
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2008085
Reviewed-by: Ian Vollick <vollick@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: weiliangc <weiliangc@chromium.org>
Reviewed-by: vmpstr <vmpstr@chromium.org>
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Mike Reed <reed@google.com>
Cr-Commit-Position: refs/heads/master@{#734009}

ash/display/overscan_calibrator.cc

@@ -63,7 +63,7 @@ void DrawTriangle(int x_offset,
   gfx::Transform move_transform;
   move_transform.Translate(x_offset, y_offset);
   rotate_transform.ConcatTransform(move_transform);
-  base_path.transform(rotate_transform.matrix(), &path);
+  base_path.transform(SkMatrix(rotate_transform.matrix()), &path);
 
   canvas->DrawPath(path, content_flags);
   canvas->DrawPath(path, border_flags);

cc/layers/render_surface_impl.cc

@@ -85,8 +85,8 @@ gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
   gfx::Rect surface_content_rect = content_rect();
   const FilterOperations& filters = Filters();
   if (!filters.IsEmpty()) {
-    surface_content_rect =
-        filters.MapRect(surface_content_rect, SurfaceScale().matrix());
+    surface_content_rect = filters.MapRect(surface_content_rect,
+                                           SkMatrix(SurfaceScale().matrix()));
   }
   gfx::RectF drawable_content_rect = MathUtil::MapClippedRect(
       draw_transform(), gfx::RectF(surface_content_rect));
@@ -210,8 +210,8 @@ gfx::Rect RenderSurfaceImpl::CalculateExpandedClipForFilters(
     const gfx::Transform& target_to_surface) {
   gfx::Rect clip_in_surface_space =
       MathUtil::ProjectEnclosingClippedRect(target_to_surface, clip_rect());
-  gfx::Rect expanded_clip_in_surface_space =
-      Filters().MapRect(clip_in_surface_space, SurfaceScale().matrix());
+  gfx::Rect expanded_clip_in_surface_space = Filters().MapRect(
+      clip_in_surface_space, SkMatrix(SurfaceScale().matrix()));
   gfx::Rect expanded_clip_in_target_space = MathUtil::MapEnclosingClippedRect(
       draw_transform(), expanded_clip_in_surface_space);
   return expanded_clip_in_target_space;

cc/paint/display_item_list_unittest.cc

@@ -333,7 +333,7 @@ TEST_F(DisplayItemListTest, TransformPairedRange) {
       SkRect::MakeLTRB(0.f + first_offset.x(), 0.f + first_offset.y(),
                        60.f + first_offset.x(), 60.f + first_offset.y()),
       red_paint);
-  expected_canvas.setMatrix(transform.matrix());
+  expected_canvas.setMatrix(SkMatrix(transform.matrix()));
   expected_canvas.drawRect(
       SkRect::MakeLTRB(50.f + second_offset.x(), 50.f + second_offset.y(),
                        75.f + second_offset.x(), 75.f + second_offset.y()),

cc/trees/clip_expander.cc

@@ -25,7 +25,8 @@ gfx::Rect ClipExpander::MapRect(const gfx::Rect& rect,
   gfx::Transform filter_draw_transform;
   filter_draw_transform.Scale(effect_node->surface_contents_scale.x(),
                               effect_node->surface_contents_scale.y());
-  return effect_node->filters.MapRect(rect, filter_draw_transform.matrix());
+  return effect_node->filters.MapRect(rect,
+                                      SkMatrix(filter_draw_transform.matrix()));
 }
 
 gfx::Rect ClipExpander::MapRectReverse(
@@ -36,8 +37,8 @@ gfx::Rect ClipExpander::MapRectReverse(
   gfx::Transform filter_draw_transform;
   filter_draw_transform.Scale(effect_node->surface_contents_scale.x(),
                               effect_node->surface_contents_scale.y());
-  return effect_node->filters.MapRectReverse(rect,
-                                             filter_draw_transform.matrix());
+  return effect_node->filters.MapRectReverse(
+      rect, SkMatrix(filter_draw_transform.matrix()));
 }
 
 }  // namespace cc

cc/trees/damage_tracker.cc

@@ -198,7 +198,7 @@ void DamageTracker::ComputeSurfaceDamage(
     bool is_rect_valid = damage_for_this_update_.GetAsRect(&damage_rect);
     if (is_rect_valid && !damage_rect.IsEmpty()) {
       damage_rect = render_surface->Filters().MapRect(
-          damage_rect, render_surface->SurfaceScale().matrix());
+          damage_rect, SkMatrix(render_surface->SurfaceScale().matrix()));
       damage_for_this_update_ = DamageAccumulator();
       damage_for_this_update_.Union(damage_rect);
     }

cc/trees/property_tree_builder_unittest.cc

@@ -353,7 +353,7 @@ TEST_F(PropertyTreeBuilderTest, VisibleRectWithClippingAndFilters) {
   gfx::Transform vertical_flip;
   vertical_flip.Scale(1, -1);
   sk_sp<PaintFilter> flip_filter = sk_make_sp<MatrixPaintFilter>(
-      vertical_flip.matrix(), kLow_SkFilterQuality, nullptr);
+      SkMatrix(vertical_flip.matrix()), kLow_SkFilterQuality, nullptr);
   FilterOperations reflection_filter;
   reflection_filter.Append(
       FilterOperation::CreateReferenceFilter(sk_make_sp<XfermodePaintFilter>(
@@ -413,7 +413,7 @@ TEST_F(PropertyTreeBuilderTest, VisibleRectWithScalingClippingAndFilters) {
   gfx::Transform vertical_flip;
   vertical_flip.Scale(1, -1);
   sk_sp<PaintFilter> flip_filter = sk_make_sp<MatrixPaintFilter>(
-      vertical_flip.matrix(), kLow_SkFilterQuality, nullptr);
+      SkMatrix(vertical_flip.matrix()), kLow_SkFilterQuality, nullptr);
   FilterOperations reflection_filter;
   reflection_filter.Append(
       FilterOperation::CreateReferenceFilter(sk_make_sp<XfermodePaintFilter>(

components/viz/service/display/gl_renderer.cc

@@ -1012,7 +1012,8 @@ sk_sp<SkImage> GLRenderer::ApplyBackdropFilters(
     surface->getCanvas()->save();
     gfx::RRectF clip_rect(backdrop_filter_bounds.value());
     clip_rect.Scale(params->backdrop_filter_quality);
-    surface->getCanvas()->setMatrix(backdrop_filter_bounds_transform.matrix());
+    surface->getCanvas()->setMatrix(
+        SkMatrix(backdrop_filter_bounds_transform.matrix()));
     surface->getCanvas()->clipRRect(SkRRect(clip_rect), SkClipOp::kIntersect,
                                     true /* antialias */);
     surface->getCanvas()->resetMatrix();

components/viz/service/display/overlay_unittest.cc

@@ -468,7 +468,7 @@ SkMatrix GetNonIdentityColorMatrix() {
   SkMatrix44 matrix = GetIdentityColorMatrix();
   matrix.set(1, 1, 0.5f);
   matrix.set(2, 2, 0.5f);
-  return matrix;
+  return SkMatrix(matrix);
 }
 
 template <typename OverlayProcessorType>

components/viz/service/display/software_renderer.cc

@@ -172,7 +172,7 @@ void SoftwareRenderer::SetClipRRect(const gfx::RRectF& rrect) {
   gfx::Transform screen_transform =
       current_frame()->window_matrix * current_frame()->projection_matrix;
   SkRRect result;
-  if (SkRRect(rrect).transform(screen_transform.matrix(), &result)) {
+  if (SkRRect(rrect).transform(SkMatrix(screen_transform.matrix()), &result)) {
     // Skia applies the current matrix to clip rects so we reset it temporarily.
     SkMatrix current_matrix = current_canvas_->getTotalMatrix();
     current_canvas_->resetMatrix();
@@ -813,7 +813,7 @@ sk_sp<SkShader> SoftwareRenderer::GetBackdropFilterShader(
     return nullptr;
 
   SkMatrix filter_backdrop_transform =
-      contents_device_transform_inverse.matrix();
+      SkMatrix(contents_device_transform_inverse.matrix());
   filter_backdrop_transform.preTranslate(backdrop_rect.x(), backdrop_rect.y());
 
   SkBitmap backdrop_bitmap = GetBackdropBitmap(backdrop_rect);
@@ -864,7 +864,7 @@ sk_sp<SkShader> SoftwareRenderer::GetBackdropFilterShader(
 
   // Clip the filtered image to the (rounded) bounding box of the element.
   if (backdrop_filter_bounds) {
-    canvas.setMatrix(backdrop_filter_bounds_transform.matrix());
+    canvas.setMatrix(SkMatrix(backdrop_filter_bounds_transform.matrix()));
     canvas.clipRRect(SkRRect(*backdrop_filter_bounds), SkClipOp::kIntersect,
                      true /* antialias */);
     canvas.resetMatrix();

content/renderer/input/synchronous_compositor_proxy.cc

@@ -217,7 +217,7 @@ void SynchronousCompositorProxy::DoDemandDrawSw(
   }
   SkCanvas canvas(bitmap);
   canvas.clipRect(gfx::RectToSkRect(params.clip));
-  canvas.concat(params.transform.matrix());
+  canvas.concat(SkMatrix(params.transform.matrix()));
 
   layer_tree_frame_sink_->DemandDrawSw(&canvas);
 }

skia/config/SkUserConfig.h

@@ -211,10 +211,6 @@ SK_API void SkDebugf_FileLine(const char* file,
 #define SK_DISABLE_REDUCE_OPLIST_SPLITTING
 #endif
 
-#ifndef SK_SUPPORT_LEGACY_IMPLICIT_CONVERSION_MATRIX44
-#define SK_SUPPORT_LEGACY_IMPLICIT_CONVERSION_MATRIX44
-#endif
-
 #ifndef SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS
 #define SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS
 #endif

third_party/blink/renderer/platform/graphics/compositing/paint_artifact_compositor.cc

@@ -957,8 +957,8 @@ scoped_refptr<cc::DisplayItemList> SynthesizedClip::PaintContentsToDisplayList(
       const auto& translation = translation_2d_or_matrix_.Translation2D();
       cc_list->push<cc::TranslateOp>(translation.Width(), translation.Height());
     } else {
-      cc_list->push<cc::ConcatOp>(TransformationMatrix::ToSkMatrix44(
-          translation_2d_or_matrix_.Matrix()));
+      cc_list->push<cc::ConcatOp>(SkMatrix(TransformationMatrix::ToSkMatrix44(
+          translation_2d_or_matrix_.Matrix())));
     }
     if (path_) {
       cc_list->push<cc::ClipPathOp>(path_->GetSkPath(), SkClipOp::kIntersect,

third_party/blink/renderer/platform/graphics/graphics_layer.cc

@@ -709,7 +709,7 @@ void GraphicsLayer::SetContentsToImage(
     auto affine =
         image_orientation.TransformFromDefault(FloatSize(image_size_));
     auto transform = affine.ToTransformationMatrix();
-    matrix = TransformationMatrix::ToSkMatrix44(transform);
+    matrix = SkMatrix(TransformationMatrix::ToSkMatrix44(transform));
   } else if (paint_image) {
     matrix = SkMatrix::I();
     image_size_ = IntSize(paint_image.width(), paint_image.height());

third_party/blink/renderer/platform/graphics/paint/geometry_mapper.h

@@ -100,7 +100,7 @@ class PLATFORM_EXPORT GeometryMapper {
         return SkMatrix::MakeTrans(Translation2D().Width(),
                                    Translation2D().Height());
       }
-      return TransformationMatrix::ToSkMatrix44(Matrix());
+      return SkMatrix(TransformationMatrix::ToSkMatrix44(Matrix()));
     }
 
     bool operator==(const Translation2DOrMatrix& other) {

ui/base/x/x11_window.cc

@@ -1577,7 +1577,7 @@ void XWindow::SetXWindowShape(std::unique_ptr<NativeShapeRects> native_shape,
       SkPath path_in_dip;
       if (native_region.getBoundaryPath(&path_in_dip)) {
         SkPath path_in_pixels;
-        path_in_dip.transform(transform.matrix(), &path_in_pixels);
+        path_in_dip.transform(SkMatrix(transform.matrix()), &path_in_pixels);
         xregion = gfx::CreateRegionFromSkPath(path_in_pixels);
       } else {
         xregion = XCreateRegion();

ui/gfx/canvas.cc

@@ -502,7 +502,7 @@ bool Canvas::InitPaintFlagsForTiling(const ImageSkia& image,
 }
 
 void Canvas::Transform(const gfx::Transform& transform) {
-  canvas_->concat(transform.matrix());
+  canvas_->concat(SkMatrix(transform.matrix()));
 }
 
 SkBitmap Canvas::GetBitmap() const {

ui/gfx/transform.cc

@@ -466,8 +466,7 @@ void Transform::TransformRect(RectF* rect) const {
     return;
 
   SkRect src = RectFToSkRect(*rect);
-  const SkMatrix& matrix = matrix_;
-  matrix.mapRect(&src);
+  SkMatrix(matrix_).mapRect(&src);
   *rect = SkRectToRectF(src);
 }
 
@@ -479,16 +478,15 @@ bool Transform::TransformRectReverse(RectF* rect) const {
   if (!matrix_.invert(&inverse))
     return false;
 
-  const SkMatrix& matrix = inverse;
   SkRect src = RectFToSkRect(*rect);
-  matrix.mapRect(&src);
+  SkMatrix(inverse).mapRect(&src);
   *rect = SkRectToRectF(src);
   return true;
 }
 
 bool Transform::TransformRRectF(RRectF* rrect) const {
   SkRRect result;
-  if (!SkRRect(*rrect).transform(matrix_, &result))
+  if (!SkRRect(*rrect).transform(SkMatrix(matrix_), &result))
     return false;
   *rrect = gfx::RRectF(result);
   return true;

ui/views/view.cc

@@ -975,7 +975,8 @@ void View::Paint(const PaintInfo& parent_paint_info) {
           SkFloatToScalar(paint_info.paint_recording_scale_x()),
           SkFloatToScalar(paint_info.paint_recording_scale_y()));
 
-      clip_path_in_parent.transform(to_parent_recording_space.matrix());
+      clip_path_in_parent.transform(
+          SkMatrix(to_parent_recording_space.matrix()));
       clip_recorder.ClipPathWithAntiAliasing(clip_path_in_parent);
     }
   }

ui/views/view_unittest.cc

@@ -12,6 +12,7 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
+
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
@@ -2983,7 +2984,7 @@ TEST_F(ViewTest, ConversionsWithTransform) {
     transform.Translate(1.0, 1.0);
 
     // convert to a 3x3 matrix.
-    const SkMatrix& matrix = transform.matrix();
+    const SkMatrix& matrix = SkMatrix(transform.matrix());
 
     EXPECT_EQ(210, matrix.getTranslateX());
     EXPECT_EQ(-55, matrix.getTranslateY());
@@ -3004,7 +3005,7 @@ TEST_F(ViewTest, ConversionsWithTransform) {
     transform.ConcatTransform(t3);
 
     // convert to a 3x3 matrix
-    const SkMatrix& matrix = transform.matrix();
+    const SkMatrix& matrix = SkMatrix(transform.matrix());
 
     EXPECT_EQ(210, matrix.getTranslateX());
     EXPECT_EQ(-55, matrix.getTranslateY());