Add variation of GetConstantValueForVariable which handles ownership.

The new function `MakeConstantValueForVariable` behaves the same, except
it takes unique_ptrs as inputs and returns a unique_ptr as output.
We already had this behavior coded up in two places and I realized I
could use this functionality in other spots as well.

Change-Id: I2f0c43e8555a3c89bf9a1eef7030b422355ec2a3
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/405680
Auto-Submit: John Stiles <johnstiles@google.com>
Commit-Queue: Ethan Nicholas <ethannicholas@google.com>
Reviewed-by: Ethan Nicholas <ethannicholas@google.com>

src/sksl/SkSLConstantFolder.cpp

@@ -233,6 +233,15 @@ const Expression* ConstantFolder::GetConstantValueForVariable(const Expression&
     return &inExpr;
 }
 
+std::unique_ptr<Expression> ConstantFolder::MakeConstantValueForVariable(
+        std::unique_ptr<Expression> expr) {
+    const Expression* constantExpr = GetConstantValueForVariable(*expr);
+    if (constantExpr != expr.get()) {
+        expr = constantExpr->clone();
+    }
+    return expr;
+}
+
 static std::unique_ptr<Expression> simplify_no_op_arithmetic(const Context& context,
                                                              const Expression& left,
                                                              Operator op,

src/sksl/SkSLConstantFolder.h

@@ -43,6 +43,13 @@ public:
      */
     static const Expression* GetConstantValueForVariable(const Expression& value);
 
+    /**
+     * If the expression is a const variable with a known compile-time-constant value, returns a
+     * clone of that value. If not, returns the original expression as-is.
+     */
+    static std::unique_ptr<Expression> MakeConstantValueForVariable(
+            std::unique_ptr<Expression> expr);
+
     /**
      * Reports an error and returns true if op is a division / mod operator and right is zero or
      * contains a zero element.

src/sksl/ir/SkSLConstructorCompound.cpp

@@ -76,10 +76,7 @@ std::unique_ptr<Expression> ConstructorCompound::Make(const Context& context,
         // Replace constant variables with their corresponding values, so `float2(one, two)` can
         // compile down to `float2(1.0, 2.0)` (the latter is a compile-time constant).
         for (std::unique_ptr<Expression>& arg : args) {
-            const Expression* value = ConstantFolder::GetConstantValueForVariable(*arg);
-            if (value != arg.get()) {
-                arg = value->clone();
-            }
+            arg = ConstantFolder::MakeConstantValueForVariable(std::move(arg));
         }
     }
 

src/sksl/ir/SkSLConstructorSplat.cpp

@@ -25,10 +25,7 @@ std::unique_ptr<Expression> ConstructorSplat::Make(const Context& context,
     if (context.fConfig->fSettings.fOptimize) {
         // Replace constant variables with their corresponding values, so `float3(five)` can
         // compile down to `float3(5.0)` (the latter is a compile-time constant).
-        const Expression* value = ConstantFolder::GetConstantValueForVariable(*arg);
-        if (value != arg.get()) {
-            arg = value->clone();
-        }
+        arg = ConstantFolder::MakeConstantValueForVariable(std::move(arg));
     }
 
     SkASSERT(type.isVector());