[DirectVariableAccess] Add option for external handles to be processed.

Currently the DVA transform will only process handles if the
`transform_handles` flag is set. This CL splits the flag into a `none`,
`external`, and `full` set of options. The current behaviour being
either `none` or `full` in all cases.

The SPIR-V backend is updated to use either `external` or `full` instead
of `none` and `full` so we can flatten any external textures before
running multiplanar.

Bug: 491363837
Change-Id: Iad7e8348e3ff278fcf6e134503626a1b071c2f1b
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/296696
Commit-Queue: dan sinclair <dsinclair@chromium.org>
Reviewed-by: James Price <jrprice@google.com>

Author: dj2

src/tint/lang/core/ir/transform/direct_variable_access.cc

@@ -37,6 +37,7 @@
 #include "src/tint/lang/core/ir/user_call.h"
 #include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/core/ir/var.h"
+#include "src/tint/lang/core/type/external_texture.h"
 #include "src/tint/utils/containers/reverse.h"
 
 using namespace tint::core::fluent_types;     // NOLINT
@@ -608,6 +609,17 @@ struct State {
         }
     }
 
+    bool TransformHandle(const type::Type* param) const {
+        if (!param->IsHandle()) {
+            return false;
+        }
+        if (options.transform_handle == HandleTransformLevel::kFull) {
+            return true;
+        }
+        return options.transform_handle == HandleTransformLevel::kExternal &&
+               param->Is<type::ExternalTexture>();
+    }
+
     /// @return true if @p param is a parameter that requires transforming, based on the
     /// transform options.
     /// @param param the function parameter
@@ -631,12 +643,7 @@ struct State {
                     break;
             }
         }
-
-        if (param_type->IsHandle()) {
-            return options.transform_handle;
-        }
-
-        return false;
+        return TransformHandle(param_type);
     }
 
     /// Walks the instructions that built @p value, deleting those that are no longer used.
@@ -659,7 +666,7 @@ struct State {
                     return let->Value();
                 },
                 [&](Load* load) {
-                    if (options.transform_handle) {
+                    if (TransformHandle(load->From()->Type()->UnwrapPtr())) {
                         TINT_DEFER(load->Destroy());
                         return load->From();
                     }

src/tint/lang/core/ir/transform/direct_variable_access.h

@@ -47,14 +47,22 @@ const core::ir::Capabilities kDirectVariableAccessCapabilities{
     core::ir::Capability::kAllow8BitIntegers,
 };
 
+/// The level of handle workspace change
+enum class HandleTransformLevel {
+    kNone,
+    kExternal,
+    kFull,
+};
+
 /// DirectVariableAccessOptions adjusts the behaviour of the transform.
 struct DirectVariableAccessOptions {
     /// If true, then 'private' sub-object pointer arguments will be transformed.
     bool transform_private = false;
     /// If true, then 'function' sub-object pointer arguments will be transformed.
     bool transform_function = false;
-    /// If true, then 'handle' sub-object handle type arguments will be transformed.
-    bool transform_handle = false;
+    /// If `kExternal` the external textures are transformed, if `kFull` then all 'handle'
+    /// sub-object handle type arguments will be transformed.
+    HandleTransformLevel transform_handle = HandleTransformLevel::kNone;
 
     /// Reflection for this class
     TINT_REFLECT(DirectVariableAccessOptions,
@@ -82,4 +90,8 @@ Result<SuccessType> DirectVariableAccess(Module& module,
 
 }  // namespace tint::core::ir::transform
 
+namespace tint {
+TINT_REFLECT_ENUM_RANGE(tint::core::ir::transform::HandleTransformLevel, kNone, kFull);
+}
+
 #endif  // SRC_TINT_LANG_CORE_IR_TRANSFORM_DIRECT_VARIABLE_ACCESS_H_