lint

Author: flar

flow/layers/layer_state_stack.cc

@@ -138,7 +138,7 @@ void MutatorContext::applyOpacity(const SkRect& bounds, SkScalar opacity) {
 
 void MutatorContext::applyImageFilter(
     const SkRect& bounds,
-    const std::shared_ptr<const DlImageFilter> filter) {
+    const std::shared_ptr<const DlImageFilter>& filter) {
   if (filter) {
     layer_state_stack_->push_attributes();
     layer_state_stack_->maybe_save_layer(filter);
@@ -148,7 +148,7 @@ void MutatorContext::applyImageFilter(
 
 void MutatorContext::applyColorFilter(
     const SkRect& bounds,
-    const std::shared_ptr<const DlColorFilter> filter) {
+    const std::shared_ptr<const DlColorFilter>& filter) {
   if (filter) {
     layer_state_stack_->push_attributes();
     layer_state_stack_->maybe_save_layer(filter);
@@ -158,7 +158,7 @@ void MutatorContext::applyColorFilter(
 
 void MutatorContext::applyBackdropFilter(
     const SkRect& bounds,
-    const std::shared_ptr<const DlImageFilter> filter,
+    const std::shared_ptr<const DlImageFilter>& filter,
     DlBlendMode blend_mode) {
   layer_state_stack_->push_backdrop(bounds, filter, blend_mode);
 }
@@ -222,21 +222,21 @@ void LayerStateStack::push_opacity(const SkRect& bounds, SkScalar opacity) {
 
 void LayerStateStack::push_color_filter(
     const SkRect& bounds,
-    const std::shared_ptr<const DlColorFilter> filter) {
+    const std::shared_ptr<const DlColorFilter>& filter) {
   state_stack_.emplace_back(std::make_unique<ColorFilterEntry>(bounds, filter));
   apply_last_entry();
 }
 
 void LayerStateStack::push_image_filter(
     const SkRect& bounds,
-    const std::shared_ptr<const DlImageFilter> filter) {
+    const std::shared_ptr<const DlImageFilter>& filter) {
   state_stack_.emplace_back(std::make_unique<ImageFilterEntry>(bounds, filter));
   apply_last_entry();
 }
 
 void LayerStateStack::push_backdrop(
     const SkRect& bounds,
-    const std::shared_ptr<const DlImageFilter> filter,
+    const std::shared_ptr<const DlImageFilter>& filter,
     DlBlendMode blend_mode) {
   state_stack_.emplace_back(std::make_unique<BackdropFilterEntry>(
       bounds, filter, blend_mode, do_checkerboard_));
@@ -329,7 +329,7 @@ void LayerStateStack::maybe_save_layer(SkScalar opacity) {
 }
 
 void LayerStateStack::maybe_save_layer(
-    const std::shared_ptr<const DlColorFilter> filter) {
+    const std::shared_ptr<const DlColorFilter>& filter) {
   if (outstanding_.color_filter || outstanding_.image_filter ||
       (outstanding_.opacity < SK_Scalar1 &&
        !filter->can_commute_with_alpha())) {
@@ -339,7 +339,7 @@ void LayerStateStack::maybe_save_layer(
 }
 
 void LayerStateStack::maybe_save_layer(
-    const std::shared_ptr<const DlImageFilter> filter) {
+    const std::shared_ptr<const DlImageFilter>& filter) {
   if (outstanding_.image_filter) {
     // TBD: compose the 2 image filters together.
     save_layer(outstanding_.save_layer_bounds);
@@ -505,7 +505,7 @@ void LayerStateStack::IntegralTransformEntry::apply(
     canvas->setMatrix(matrix);
   }
   if (builder != nullptr) {
-    auto matrix = canvas->getTotalMatrix();
+    auto matrix = builder->getTransform();
     matrix = RasterCacheUtil::GetIntegralTransCTM(matrix);
     builder->transformReset();
     builder->transform(matrix);

flow/layers/layer_state_stack.h

@@ -70,15 +70,15 @@ class LayerStateStack {
     // outstanding attributes.
     // (Currently only opacity is recorded for batching)
     void applyImageFilter(const SkRect& bounds,
-                          const std::shared_ptr<const DlImageFilter> filter);
+                          const std::shared_ptr<const DlImageFilter>& filter);
 
     // Records the color filter for application at the next call to
     // saveLayer or applyState. A saveLayer may be executed at
     // this time if the color filter cannot be batched with other
     // outstanding attributes.
     // (Currently only opacity is recorded for batching)
     void applyColorFilter(const SkRect& bounds,
-                          const std::shared_ptr<const DlColorFilter> filter);
+                          const std::shared_ptr<const DlColorFilter>& filter);
 
     // Saves the state stack and immediately executes a saveLayer
     // with the indicated backdrop filter and any outstanding
@@ -89,7 +89,7 @@ class LayerStateStack {
     // subsequent canvas or builder objects that are made delegates
     // will only see a saveLayer with the indicated blend_mode.
     void applyBackdropFilter(const SkRect& bounds,
-                             const std::shared_ptr<const DlImageFilter> filter,
+                             const std::shared_ptr<const DlImageFilter>& filter,
                              DlBlendMode blend_mode);
 
     void translate(SkScalar tx, SkScalar ty);
@@ -122,11 +122,11 @@ class LayerStateStack {
 
   SkScalar outstanding_opacity() { return outstanding_.opacity; }
 
-  const std::shared_ptr<const DlColorFilter> outstanding_color_filter() {
+  std::shared_ptr<const DlColorFilter> outstanding_color_filter() {
     return outstanding_.color_filter;
   }
 
-  const std::shared_ptr<const DlImageFilter> outstanding_image_filter() {
+  std::shared_ptr<const DlImageFilter> outstanding_image_filter() {
     return outstanding_.image_filter;
   }
 
@@ -165,11 +165,11 @@ class LayerStateStack {
   void push_attributes();
   void push_opacity(const SkRect& rect, SkScalar opacity);
   void push_color_filter(const SkRect& bounds,
-                         const std::shared_ptr<const DlColorFilter> filter);
+                         const std::shared_ptr<const DlColorFilter>& filter);
   void push_image_filter(const SkRect& bounds,
-                         const std::shared_ptr<const DlImageFilter> filter);
+                         const std::shared_ptr<const DlImageFilter>& filter);
   void push_backdrop(const SkRect& bounds,
-                     const std::shared_ptr<const DlImageFilter> filter,
+                     const std::shared_ptr<const DlImageFilter>& filter,
                      DlBlendMode blend_mode);
 
   void push_translate(SkScalar tx, SkScalar ty);
@@ -194,17 +194,10 @@ class LayerStateStack {
   void maybe_save_layer_for_clip();
   void maybe_save_layer(int apply_flags);
   void maybe_save_layer(SkScalar opacity);
-  void maybe_save_layer(const std::shared_ptr<const DlColorFilter> filter);
-  void maybe_save_layer(const std::shared_ptr<const DlImageFilter> filter);
+  void maybe_save_layer(const std::shared_ptr<const DlColorFilter>& filter);
+  void maybe_save_layer(const std::shared_ptr<const DlImageFilter>& filter);
   // ---------------------
 
-  static std::optional<SkRect> OptionalBounds(const SkRect* bounds) {
-    return bounds ? std::make_optional<SkRect>(*bounds) : std::nullopt;
-  }
-  static const SkRect* BoundsPtr(const std::optional<SkRect>& bounds) {
-    return bounds.has_value() ? &bounds.value() : nullptr;
-  }
-
   struct RenderingAttributes {
     // We need to record the last bounds we received for the last
     // attribute that we recorded so that we can perform a saveLayer
@@ -322,7 +315,7 @@ class LayerStateStack {
   class ImageFilterEntry : public StateEntry {
    public:
     ImageFilterEntry(const SkRect& bounds,
-                     const std::shared_ptr<const DlImageFilter> filter)
+                     const std::shared_ptr<const DlImageFilter>& filter)
         : bounds_(bounds), filter_(filter) {}
     ~ImageFilterEntry() override = default;
 
@@ -338,7 +331,7 @@ class LayerStateStack {
   class ColorFilterEntry : public StateEntry {
    public:
     ColorFilterEntry(const SkRect& bounds,
-                     const std::shared_ptr<const DlColorFilter> filter)
+                     const std::shared_ptr<const DlColorFilter>& filter)
         : bounds_(bounds), filter_(filter) {}
     ~ColorFilterEntry() override = default;
 
@@ -354,7 +347,7 @@ class LayerStateStack {
   class BackdropFilterEntry : public SaveLayerEntry {
    public:
     BackdropFilterEntry(const SkRect& bounds,
-                        const std::shared_ptr<const DlImageFilter> filter,
+                        const std::shared_ptr<const DlImageFilter>& filter,
                         DlBlendMode blend_mode,
                         bool checkerboard)
         : SaveLayerEntry(bounds, blend_mode, checkerboard), filter_(filter) {}