Introduces code to calculate the minimum required version of Ink for a BrushFamily (and each part of a BrushFamily). The code is used during serialization to compute the value to store in the min_version field. During deserialization, the min_version field is used to determine if a BrushFamily is compatible with the current version of Ink; if it isn't, decoding it is aborted.

To ensure the code in the web of `CalculateMinimumRequiredVersion` functions lines up with expectations, protobuf options are used to build consistency check tests. `CalculateMinimumRequiredVersion` serves as the enforcement of the expectations set in the protobuf itself. The tests are:
* A fuzz test to generate valid brush families and serialize them. Then, it checks the value in `min_version` against all the options set for the fields, messages, and enum values, to ensure it is equal to the highest value set for the relevant options. This ensures `CalculateMinimumRequiredVersion` is consistent with the protobuf options.
* A test to iterate over all the messages, fields, and enum values in `brush_family.proto`, starting at the top-level `BrushFamily` message, and verify that they all have a relevant `field_min_version`, `message_min_version`, or `enum_value_min_version` set, and that this value set is less than or equal to the maximum compatible version (`version::kMax`).
* A test to verify that decoding a `proto::Version` higher than `version::kMax` will fail.
* A test to verify that decoding a `proto::Version` with an unrecognized `proto::Version::Cycle` enum value will fail.
* A test to verify that decoding a `proto::BrushFamily` with no value set for its `min_version` field will ***not*** fail, to ensure older brushes are still able to be loaded.

A more direct implementation, using reflection to examine the descriptors of the protobuf directly during serialization, was considered, but ultimately rejected. It would have required both static and runtime reflection, and increased `libink.so` size by ~2%.

PiperOrigin-RevId: 872916698

Author: maxmmitchell

ink/brush/BUILD.bazel

@@ -33,6 +33,7 @@ cc_library(
         ":brush_tip",
         ":color_function",
         ":easing_function",
+        ":version",
         "//:gtest_for_library_testonly",
         "//ink/geometry:type_matchers",
         "//ink/types:type_matchers",
@@ -82,9 +83,9 @@ cc_library(
     srcs = ["brush_coat.cc"],
     hdrs = ["brush_coat.h"],
     deps = [
-        ":brush_behavior",
         ":brush_paint",
         ":brush_tip",
+        ":version",
         "//ink/geometry:mesh_format",
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/container:inlined_vector",
@@ -120,6 +121,7 @@ cc_library(
         ":brush_coat",
         ":brush_paint",
         ":brush_tip",
+        ":version",
         "//ink/types:duration",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
@@ -160,6 +162,7 @@ cc_library(
     hdrs = ["brush_tip.h"],
     deps = [
         ":brush_behavior",
+        ":version",
         "//ink/geometry:angle",
         "//ink/geometry:mesh_format",
         "//ink/geometry:vec",
@@ -190,6 +193,7 @@ cc_library(
     srcs = ["color_function.cc"],
     hdrs = ["color_function.h"],
     deps = [
+        ":version",
         "//ink/color",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/strings",
@@ -219,6 +223,7 @@ cc_library(
     srcs = ["easing_function.cc"],
     hdrs = ["easing_function.h"],
     deps = [
+        ":version",
         "//ink/geometry:point",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/strings",
@@ -245,6 +250,7 @@ cc_library(
     hdrs = ["brush_behavior.h"],
     deps = [
         ":easing_function",
+        ":version",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
@@ -273,6 +279,7 @@ cc_library(
     hdrs = ["brush_paint.h"],
     deps = [
         ":color_function",
+        ":version",
         "//ink/geometry:angle",
         "//ink/geometry:mesh_format",
         "//ink/geometry:vec",
@@ -365,6 +372,12 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "version",
+    hdrs = ["version.h"],
+    deps = ["@com_google_absl//absl/strings"],
+)
+
 cc_test(
     name = "stock_brushes_test",
     srcs = ["stock_brushes_test.cc"],

ink/brush/brush_behavior.cc

@@ -25,6 +25,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "ink/brush/easing_function.h"
+#include "ink/brush/version.h"
 
 namespace ink {
 
@@ -473,6 +474,277 @@ absl::Status ValidateBrushBehavior(const BrushBehavior& behavior) {
   return absl::OkStatus();
 }
 
+namespace {
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::Source source) {
+  Version max_version = version::k1_0_0;
+  switch (source) {
+    case BrushBehavior::Source::kNormalizedPressure:
+    case BrushBehavior::Source::kTiltInRadians:
+    case BrushBehavior::Source::kTiltXInRadians:
+    case BrushBehavior::Source::kTiltYInRadians:
+    case BrushBehavior::Source::kOrientationInRadians:
+    case BrushBehavior::Source::kOrientationAboutZeroInRadians:
+    case BrushBehavior::Source::kSpeedInMultiplesOfBrushSizePerSecond:
+    case BrushBehavior::Source::kVelocityXInMultiplesOfBrushSizePerSecond:
+    case BrushBehavior::Source::kVelocityYInMultiplesOfBrushSizePerSecond:
+    case BrushBehavior::Source::kDirectionInRadians:
+    case BrushBehavior::Source::kDirectionAboutZeroInRadians:
+    case BrushBehavior::Source::kNormalizedDirectionX:
+    case BrushBehavior::Source::kNormalizedDirectionY:
+    case BrushBehavior::Source::kDistanceTraveledInMultiplesOfBrushSize:
+    case BrushBehavior::Source::kTimeOfInputInSeconds:
+    case BrushBehavior::Source::
+        kPredictedDistanceTraveledInMultiplesOfBrushSize:
+    case BrushBehavior::Source::kPredictedTimeElapsedInSeconds:
+    case BrushBehavior::Source::kDistanceRemainingInMultiplesOfBrushSize:
+    case BrushBehavior::Source::kTimeSinceInputInSeconds:
+    case BrushBehavior::Source::
+        kAccelerationInMultiplesOfBrushSizePerSecondSquared:
+    case BrushBehavior::Source::
+        kAccelerationXInMultiplesOfBrushSizePerSecondSquared:
+    case BrushBehavior::Source::
+        kAccelerationYInMultiplesOfBrushSizePerSecondSquared:
+    case BrushBehavior::Source::
+        kAccelerationForwardInMultiplesOfBrushSizePerSecondSquared:
+    case BrushBehavior::Source::
+        kAccelerationLateralInMultiplesOfBrushSizePerSecondSquared:
+    case BrushBehavior::Source::kInputSpeedInCentimetersPerSecond:
+    case BrushBehavior::Source::kInputVelocityXInCentimetersPerSecond:
+    case BrushBehavior::Source::kInputVelocityYInCentimetersPerSecond:
+    case BrushBehavior::Source::kInputDistanceTraveledInCentimeters:
+    case BrushBehavior::Source::kPredictedInputDistanceTraveledInCentimeters:
+    case BrushBehavior::Source::kInputAccelerationInCentimetersPerSecondSquared:
+    case BrushBehavior::Source::
+        kInputAccelerationXInCentimetersPerSecondSquared:
+    case BrushBehavior::Source::
+        kInputAccelerationYInCentimetersPerSecondSquared:
+    case BrushBehavior::Source::
+        kInputAccelerationForwardInCentimetersPerSecondSquared:
+    case BrushBehavior::Source::
+        kInputAccelerationLateralInCentimetersPerSecondSquared:
+    case BrushBehavior::Source::kDistanceRemainingAsFractionOfStrokeLength:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::Target target) {
+  Version max_version = version::k1_0_0;
+  switch (target) {
+    case BrushBehavior::Target::kWidthMultiplier:
+    case BrushBehavior::Target::kHeightMultiplier:
+    case BrushBehavior::Target::kSizeMultiplier:
+    case BrushBehavior::Target::kSlantOffsetInRadians:
+    case BrushBehavior::Target::kPinchOffset:
+    case BrushBehavior::Target::kRotationOffsetInRadians:
+    case BrushBehavior::Target::kCornerRoundingOffset:
+    case BrushBehavior::Target::kPositionOffsetXInMultiplesOfBrushSize:
+    case BrushBehavior::Target::kPositionOffsetYInMultiplesOfBrushSize:
+    case BrushBehavior::Target::kPositionOffsetForwardInMultiplesOfBrushSize:
+    case BrushBehavior::Target::kPositionOffsetLateralInMultiplesOfBrushSize:
+    case BrushBehavior::Target::kTextureAnimationProgressOffset:
+    case BrushBehavior::Target::kHueOffsetInRadians:
+    case BrushBehavior::Target::kSaturationMultiplier:
+    case BrushBehavior::Target::kLuminosity:
+    case BrushBehavior::Target::kOpacityMultiplier:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTarget target) {
+  Version max_version = version::k1_0_0;
+  switch (target) {
+    case BrushBehavior::PolarTarget::
+        kPositionOffsetAbsoluteInRadiansAndMultiplesOfBrushSize:
+    case BrushBehavior::PolarTarget::
+        kPositionOffsetRelativeInRadiansAndMultiplesOfBrushSize:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::OutOfRange out_of_range) {
+  Version max_version = version::k1_0_0;
+  switch (out_of_range) {
+    case BrushBehavior::OutOfRange::kClamp:
+    case BrushBehavior::OutOfRange::kMirror:
+    case BrushBehavior::OutOfRange::kRepeat:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::EnabledToolTypes enabled) {
+  Version max_version = version::k1_0_0;
+  if (enabled.unknown || enabled.mouse || enabled.stylus || enabled.touch) {
+    return max_version;
+  }
+  // A tool type filter is compatible with the lowest version that supports any
+  // of the included tool types.
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::OptionalInputProperty input) {
+  Version max_version = version::k1_0_0;
+  switch (input) {
+    case BrushBehavior::OptionalInputProperty::kPressure:
+    case BrushBehavior::OptionalInputProperty::kTilt:
+    case BrushBehavior::OptionalInputProperty::kOrientation:
+    case BrushBehavior::OptionalInputProperty::kTiltXAndY:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOp operation) {
+  Version max_version = version::k1_0_0;
+  switch (operation) {
+    case BrushBehavior::BinaryOp::kProduct:
+    case BrushBehavior::BinaryOp::kSum:
+      break;
+    case BrushBehavior::BinaryOp::kMin:
+    case BrushBehavior::BinaryOp::kMax:
+      max_version = MaxVersion(max_version, version::k1_1_0_alpha_01);
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::ProgressDomain progress_domain) {
+  Version max_version = version::k1_0_0;
+  switch (progress_domain) {
+    case BrushBehavior::ProgressDomain::kDistanceInCentimeters:
+    case BrushBehavior::ProgressDomain::kDistanceInMultiplesOfBrushSize:
+    case BrushBehavior::ProgressDomain::kTimeInSeconds:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::Interpolation interpolation) {
+  Version max_version = version::k1_0_0;
+  switch (interpolation) {
+    case BrushBehavior::Interpolation::kLerp:
+    case BrushBehavior::Interpolation::kInverseLerp:
+      break;
+  }
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::SourceNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(max_version, CalculateMinimumRequiredVersion(
+                                            node.source_out_of_range_behavior));
+  max_version =
+      MaxVersion(max_version, CalculateMinimumRequiredVersion(node.source));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::ConstantNode node) {
+  Version max_version = version::k1_0_0;
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::NoiseNode node) {
+  Version max_version = version::k1_0_0;
+  max_version =
+      MaxVersion(max_version, CalculateMinimumRequiredVersion(node.vary_over));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::FallbackFilterNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(
+      max_version, CalculateMinimumRequiredVersion(node.is_fallback_for));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::ToolTypeFilterNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(
+      max_version, CalculateMinimumRequiredVersion(node.enabled_tool_types));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::DampingNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(
+      max_version, CalculateMinimumRequiredVersion(node.damping_source));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::ResponseNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(
+      max_version,
+      brush_internal::CalculateMinimumRequiredVersion(node.response_curve));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::IntegralNode node) {
+  Version max_version = version::k1_1_0_alpha_01;
+  max_version = MaxVersion(
+      max_version, CalculateMinimumRequiredVersion(node.integrate_over));
+  max_version = MaxVersion(
+      max_version,
+      CalculateMinimumRequiredVersion(node.integral_out_of_range_behavior));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOpNode node) {
+  Version max_version = version::k1_0_0;
+  max_version =
+      MaxVersion(max_version, CalculateMinimumRequiredVersion(node.operation));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::InterpolationNode node) {
+  Version max_version = version::k1_0_0;
+  max_version = MaxVersion(max_version,
+                           CalculateMinimumRequiredVersion(node.interpolation));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::TargetNode node) {
+  Version max_version = version::k1_0_0;
+  max_version =
+      MaxVersion(max_version, CalculateMinimumRequiredVersion(node.target));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTargetNode node) {
+  Version max_version = version::k1_0_0;
+  max_version =
+      MaxVersion(max_version, CalculateMinimumRequiredVersion(node.target));
+  return max_version;
+}
+
+Version CalculateMinimumRequiredVersion(const BrushBehavior::Node& node) {
+  return std::visit(
+      [](const auto& node) { return CalculateMinimumRequiredVersion(node); },
+      node);
+}
+
+}  // namespace
+
+Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior) {
+  Version max_version = version::k1_0_0;
+  for (const BrushBehavior::Node& node : behavior.nodes) {
+    max_version =
+        MaxVersion(max_version, CalculateMinimumRequiredVersion(node));
+  }
+  return max_version;
+}
+
 std::string ToFormattedString(BrushBehavior::Source source) {
   switch (source) {
     case BrushBehavior::Source::kNormalizedPressure:

ink/brush/brush_behavior.h

@@ -23,6 +23,7 @@
 
 #include "absl/status/status.h"
 #include "ink/brush/easing_function.h"
+#include "ink/brush/version.h"
 
 namespace ink {
 
@@ -690,6 +691,10 @@ absl::Status ValidateBrushBehaviorTopLevel(const BrushBehavior& behavior);
 
 absl::Status ValidateBrushBehaviorNode(const BrushBehavior::Node& node);
 
+// Calculates the minimum version of the Ink library that is required to use
+// this brush behavior.
+Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior);
+
 std::string ToFormattedString(BrushBehavior::Source source);
 std::string ToFormattedString(BrushBehavior::Target target);
 std::string ToFormattedString(BrushBehavior::PolarTarget target);