Clang-tidy: made verbose print out commands and fixed quoting problem for warnings as errors (#37015)

Author: gaaclarke

display_list/display_list_builder.cc

@@ -863,7 +863,7 @@ void DisplayListBuilder::drawPoints(SkCanvas::PointMode mode,
 }
 void DisplayListBuilder::drawSkVertices(const sk_sp<SkVertices> vertices,
                                         SkBlendMode mode) {
-  Push<DrawSkVerticesOp>(0, 1, std::move(vertices), mode);
+  Push<DrawSkVerticesOp>(0, 1, vertices, mode);
   // DrawVertices applies its colors to the paint so we have no way
   // of controlling opacity using the current paint attributes.
   // Although, examination of the |mode| might find some predictable
@@ -892,8 +892,8 @@ void DisplayListBuilder::drawImage(const sk_sp<DlImage> image,
                                    DlImageSampling sampling,
                                    bool render_with_attributes) {
   render_with_attributes
-      ? Push<DrawImageWithAttrOp>(0, 1, std::move(image), point, sampling)
-      : Push<DrawImageOp>(0, 1, std::move(image), point, sampling);
+      ? Push<DrawImageWithAttrOp>(0, 1, image, point, sampling)
+      : Push<DrawImageOp>(0, 1, image, point, sampling);
   CheckLayerOpacityCompatibility(render_with_attributes);
 }
 void DisplayListBuilder::drawImage(const sk_sp<DlImage>& image,
@@ -914,8 +914,8 @@ void DisplayListBuilder::drawImageRect(const sk_sp<DlImage> image,
                                        DlImageSampling sampling,
                                        bool render_with_attributes,
                                        SkCanvas::SrcRectConstraint constraint) {
-  Push<DrawImageRectOp>(0, 1, std::move(image), src, dst, sampling,
-                        render_with_attributes, constraint);
+  Push<DrawImageRectOp>(0, 1, image, src, dst, sampling, render_with_attributes,
+                        constraint);
   CheckLayerOpacityCompatibility(render_with_attributes);
 }
 void DisplayListBuilder::drawImageRect(const sk_sp<DlImage>& image,
@@ -938,9 +938,8 @@ void DisplayListBuilder::drawImageNine(const sk_sp<DlImage> image,
                                        DlFilterMode filter,
                                        bool render_with_attributes) {
   render_with_attributes
-      ? Push<DrawImageNineWithAttrOp>(0, 1, std::move(image), center, dst,
-                                      filter)
-      : Push<DrawImageNineOp>(0, 1, std::move(image), center, dst, filter);
+      ? Push<DrawImageNineWithAttrOp>(0, 1, image, center, dst, filter)
+      : Push<DrawImageNineOp>(0, 1, image, center, dst, filter);
   CheckLayerOpacityCompatibility(render_with_attributes);
 }
 void DisplayListBuilder::drawImageNine(const sk_sp<DlImage>& image,
@@ -971,9 +970,9 @@ void DisplayListBuilder::drawImageLattice(const sk_sp<DlImage> image,
       (x_div_count + y_div_count) * sizeof(int) +
       cell_count * (sizeof(SkColor) + sizeof(SkCanvas::Lattice::RectType));
   SkIRect src = lattice.fBounds ? *lattice.fBounds : image->bounds();
-  void* pod = this->Push<DrawImageLatticeOp>(
-      bytes, 1, std::move(image), x_div_count, y_div_count, cell_count, src,
-      dst, filter, render_with_attributes);
+  void* pod = this->Push<DrawImageLatticeOp>(bytes, 1, image, x_div_count,
+                                             y_div_count, cell_count, src, dst,
+                                             filter, render_with_attributes);
   CopyV(pod, lattice.fXDivs, x_div_count, lattice.fYDivs, y_div_count,
         lattice.fColors, cell_count, lattice.fRectTypes, cell_count);
   CheckLayerOpacityCompatibility(render_with_attributes);
@@ -992,22 +991,22 @@ void DisplayListBuilder::drawAtlas(const sk_sp<DlImage> atlas,
   if (colors != nullptr) {
     bytes += count * sizeof(DlColor);
     if (cull_rect != nullptr) {
-      data_ptr = Push<DrawAtlasCulledOp>(bytes, 1, std::move(atlas), count,
-                                         mode, sampling, true, *cull_rect,
-                                         render_with_attributes);
+      data_ptr =
+          Push<DrawAtlasCulledOp>(bytes, 1, atlas, count, mode, sampling, true,
+                                  *cull_rect, render_with_attributes);
     } else {
-      data_ptr = Push<DrawAtlasOp>(bytes, 1, std::move(atlas), count, mode,
-                                   sampling, true, render_with_attributes);
+      data_ptr = Push<DrawAtlasOp>(bytes, 1, atlas, count, mode, sampling, true,
+                                   render_with_attributes);
     }
     CopyV(data_ptr, xform, count, tex, count, colors, count);
   } else {
     if (cull_rect != nullptr) {
-      data_ptr = Push<DrawAtlasCulledOp>(bytes, 1, std::move(atlas), count,
-                                         mode, sampling, false, *cull_rect,
-                                         render_with_attributes);
+      data_ptr =
+          Push<DrawAtlasCulledOp>(bytes, 1, atlas, count, mode, sampling, false,
+                                  *cull_rect, render_with_attributes);
     } else {
-      data_ptr = Push<DrawAtlasOp>(bytes, 1, std::move(atlas), count, mode,
-                                   sampling, false, render_with_attributes);
+      data_ptr = Push<DrawAtlasOp>(bytes, 1, atlas, count, mode, sampling,
+                                   false, render_with_attributes);
     }
     CopyV(data_ptr, xform, count, tex, count);
   }
@@ -1069,7 +1068,7 @@ void DisplayListBuilder::drawDisplayList(
 void DisplayListBuilder::drawTextBlob(const sk_sp<SkTextBlob> blob,
                                       SkScalar x,
                                       SkScalar y) {
-  Push<DrawTextBlobOp>(0, 1, std::move(blob), x, y);
+  Push<DrawTextBlobOp>(0, 1, blob, x, y);
   CheckLayerOpacityCompatibility();
 }
 void DisplayListBuilder::drawShadow(const SkPath& path,

flow/compositor_context.cc

@@ -81,7 +81,8 @@ std::unique_ptr<CompositorContext::ScopedFrame> CompositorContext::AcquireFrame(
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
     bool surface_supports_readback,
-    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger,
+    fml::RefPtr<fml::RasterThreadMerger>
+        raster_thread_merger,  // NOLINT(performance-unnecessary-value-param)
     DisplayListBuilder* display_list_builder) {
   return std::make_unique<ScopedFrame>(
       *this, gr_context, canvas, view_embedder, root_surface_transformation,

flow/diff_context.cc

@@ -202,7 +202,7 @@ void DiffContext::AddReadbackRegion(const SkIRect& rect) {
   readback.position = rects_->size();
   // Push empty rect as a placeholder for position in current subtree
   rects_->push_back(SkRect::MakeEmpty());
-  readbacks_.push_back(std::move(readback));
+  readbacks_.push_back(readback);
 }
 
 PaintRegion DiffContext::CurrentSubtreeRegion() const {

impeller/aiks/aiks_unittests.cc

@@ -6,6 +6,7 @@
 #include <cmath>
 #include <iostream>
 #include <tuple>
+#include <utility>
 
 #include "flutter/testing/testing.h"
 #include "impeller/aiks/aiks_playground.h"
@@ -74,7 +75,7 @@ TEST_P(AiksTest, CanRenderImage) {
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
 
-bool GenerateMipmap(std::shared_ptr<Context> context,
+bool GenerateMipmap(const std::shared_ptr<Context>& context,
                     std::shared_ptr<Texture> texture,
                     std::string label) {
   auto buffer = context->CreateCommandBuffer();
@@ -85,7 +86,7 @@ bool GenerateMipmap(std::shared_ptr<Context> context,
   if (!pass) {
     return false;
   }
-  pass->GenerateMipmap(texture, label);
+  pass->GenerateMipmap(std::move(texture), std::move(label));
   pass->EncodeCommands(context->GetResourceAllocator());
   return true;
 }
@@ -481,8 +482,8 @@ TEST_P(AiksTest, CanRenderLinearGradientWayManyColors) {
                           colors = std::move(colors)]() {
       auto contents = std::make_shared<LinearGradientContents>();
       contents->SetEndPoints({0, 0}, {200, 200});
-      contents->SetColors(std::move(colors));
-      contents->SetStops(std::move(stops));
+      contents->SetColors(colors);
+      contents->SetStops(stops);
       contents->SetTileMode(tile_mode);
       contents->SetMatrix(matrix);
       return contents;
@@ -1077,7 +1078,7 @@ TEST_P(AiksTest, CanRenderDifferencePaths) {
   canvas.DrawImage(
       std::make_shared<Image>(CreateTextureForFixture("boston.jpg")), {10, 10},
       Paint{});
-  canvas.DrawPath(std::move(path), paint);
+  canvas.DrawPath(path, paint);
 
   ASSERT_TRUE(OpenPlaygroundHere(canvas.EndRecordingAsPicture()));
 }
@@ -1097,7 +1098,7 @@ static sk_sp<SkData> OpenFixtureAsSkData(const char* fixture_name) {
   return data;
 }
 
-bool RenderTextInCanvas(std::shared_ptr<Context> context,
+bool RenderTextInCanvas(const std::shared_ptr<Context>& context,
                         Canvas& canvas,
                         const std::string& text,
                         const std::string& font_fixture,
@@ -1129,7 +1130,7 @@ bool RenderTextInCanvas(std::shared_ptr<Context> context,
 
   Paint text_paint;
   text_paint.color = Color::Yellow();
-  canvas.DrawTextFrame(std::move(frame), text_position, text_paint);
+  canvas.DrawTextFrame(frame, text_position, text_paint);
   return true;
 }
 
@@ -1725,7 +1726,7 @@ TEST_P(AiksTest, SaveLayerFiltersScaleWithTransform) {
   canvas.Translate(Vector2(100, 100));
 
   auto texture = std::make_shared<Image>(CreateTextureForFixture("boston.jpg"));
-  auto draw_image_layer = [&canvas, &texture](Paint paint) {
+  auto draw_image_layer = [&canvas, &texture](const Paint& paint) {
     canvas.SaveLayer(paint);
     canvas.DrawImage(texture, {}, Paint{});
     canvas.Restore();