Internal change only

PiperOrigin-RevId: 731351972

Author: sfreilich

ink/brush/brush_paint.cc

@@ -225,12 +225,7 @@ absl::Status ValidateBrushPaintTextureLayer(
   return absl::OkStatus();
 }
 
-absl::Status ValidateBrushPaint(const BrushPaint& paint) {
-  for (const BrushPaint::TextureLayer& layer : paint.texture_layers) {
-    if (auto status = ValidateBrushPaintTextureLayer(layer); !status.ok()) {
-      return status;
-    }
-  }
+absl::Status ValidateBrushPaintTopLevel(const BrushPaint& paint) {
   if (!paint.texture_layers.empty()) {
     int first_animation_frames = paint.texture_layers[0].animation_frames;
     BrushPaint::TextureMapping first_mapping = paint.texture_layers[0].mapping;
@@ -254,6 +249,19 @@ absl::Status ValidateBrushPaint(const BrushPaint& paint) {
   return absl::OkStatus();
 }
 
+absl::Status ValidateBrushPaint(const BrushPaint& paint) {
+  for (const BrushPaint::TextureLayer& layer : paint.texture_layers) {
+    if (absl::Status status = ValidateBrushPaintTextureLayer(layer);
+        !status.ok()) {
+      return status;
+    }
+  }
+  if (absl::Status status = ValidateBrushPaintTopLevel(paint); !status.ok()) {
+    return status;
+  }
+  return absl::OkStatus();
+}
+
 std::string ToFormattedString(BrushPaint::TextureMapping texture_mapping) {
   switch (texture_mapping) {
     case BrushPaint::TextureMapping::kTiling:

ink/brush/brush_paint.h

@@ -291,6 +291,9 @@ namespace brush_internal {
 // Determines whether the given `BrushPaint` struct is valid to be used in a
 // `BrushFamily`, and returns an error if not.
 absl::Status ValidateBrushPaint(const BrushPaint& paint);
+// Determines whether the given `BrushPaint` struct is valid to be used in a
+// `BrushFamily` assuming that the `BrushPaint::TextureLayer`s are valid.
+absl::Status ValidateBrushPaintTopLevel(const BrushPaint& paint);
 // Determines whether the given `BrushPaint::TextureLayer` struct is valid to be
 // used in a `BrushPaint`, and returns an error if not.
 absl::Status ValidateBrushPaintTextureLayer(

ink/brush/internal/jni/BUILD.bazel

@@ -63,6 +63,7 @@ cc_library(
     srcs = ["brush_tip_jni.cc"],
     deps = [
         ":brush_behavior_jni",
+        ":brush_jni_helper",
         "//ink/brush",
         "//ink/brush:brush_behavior",
         "//ink/brush:brush_tip",

ink/brush/internal/jni/brush_coat_jni.cc

@@ -24,37 +24,65 @@
 #include "ink/brush/internal/jni/brush_jni_helper.h"
 #include "ink/jni/internal/jni_defines.h"
 
+namespace {
+
+using ::ink::BrushCoat;
+using ::ink::BrushPaint;
+using ::ink::BrushTip;
+using ::ink::jni::CastToBrushCoat;
+using ::ink::jni::CastToBrushPaint;
+using ::ink::jni::CastToBrushTip;
+
+}  // namespace
+
 extern "C" {
 
 // Construct a native BrushCoat and return a pointer to it as a long.
-JNI_METHOD(brush, BrushCoat, jlong, nativeCreateBrushCoat)
+JNI_METHOD(brush, BrushCoatNative, jlong, create)
 (JNIEnv* env, jobject thiz, jlongArray tip_native_pointer_array,
  jlong paint_native_pointer) {
-  std::vector<ink::BrushTip> tips;
+  std::vector<BrushTip> tips;
   const jsize num_tips = env->GetArrayLength(tip_native_pointer_array);
   tips.reserve(num_tips);
   jlong* tip_pointers =
       env->GetLongArrayElements(tip_native_pointer_array, nullptr);
   ABSL_CHECK(tip_pointers != nullptr);
   for (jsize i = 0; i < num_tips; ++i) {
-    tips.push_back(ink::CastToBrushTip(tip_pointers[i]));
+    tips.push_back(CastToBrushTip(tip_pointers[i]));
   }
   env->ReleaseLongArrayElements(
       tip_native_pointer_array, tip_pointers,
       // No need to copy back the array, which is not modified.
       JNI_ABORT);
 
-  const ink::BrushPaint& paint = ink::CastToBrushPaint(paint_native_pointer);
+  const BrushPaint& paint = CastToBrushPaint(paint_native_pointer);
 
-  return reinterpret_cast<jlong>(new ink::BrushCoat{
+  return reinterpret_cast<jlong>(new BrushCoat{
       .tips = std::move(tips),
       .paint = paint,
   });
 }
 
-JNI_METHOD(brush, BrushCoat, void, nativeFreeBrushCoat)
+JNI_METHOD(brush, BrushCoatNative, void, free)
+(JNIEnv* env, jobject thiz, jlong native_pointer) {
+  delete reinterpret_cast<BrushCoat*>(native_pointer);
+}
+
+JNI_METHOD(brush, BrushCoatNative, jint, getBrushTipCount)
+(JNIEnv* env, jobject thiz, jlong native_pointer) {
+  return CastToBrushCoat(native_pointer).tips.size();
+}
+
+JNI_METHOD(brush, BrushCoatNative, jlong, newCopyOfBrushTip)
+(JNIEnv* env, jobject thiz, jlong native_pointer, jint tip_index) {
+  const BrushCoat& coat = CastToBrushCoat(native_pointer);
+  return reinterpret_cast<jlong>(new BrushTip(coat.tips[tip_index]));
+}
+
+JNI_METHOD(brush, BrushCoatNative, jlong, newCopyOfBrushPaint)
 (JNIEnv* env, jobject thiz, jlong native_pointer) {
-  delete reinterpret_cast<ink::BrushCoat*>(native_pointer);
+  const BrushCoat& coat = CastToBrushCoat(native_pointer);
+  return reinterpret_cast<jlong>(new BrushPaint(coat.paint));
 }
 
 }  // extern "C"

ink/brush/internal/jni/brush_family_jni.cc

@@ -32,8 +32,8 @@ namespace {
 
 using ::ink::BrushCoat;
 using ::ink::BrushFamily;
-using ::ink::CastToBrushCoat;
-using ::ink::CastToBrushFamily;
+using ::ink::jni::CastToBrushCoat;
+using ::ink::jni::CastToBrushFamily;
 using ::ink::jni::JStringView;
 using ::ink::jni::ThrowExceptionFromStatus;
 
@@ -94,4 +94,16 @@ JNI_METHOD(brush, BrushFamilyNative, jboolean, usesSpringModelV2)
       brush_family.GetInputModel());
 }
 
+JNI_METHOD(brush, BrushFamilyNative, jlong, getBrushCoatCount)
+(JNIEnv* env, jobject object, jlong native_pointer) {
+  const BrushFamily& brush_family = CastToBrushFamily(native_pointer);
+  return brush_family.GetCoats().size();
+}
+
+JNI_METHOD(brush, BrushFamilyNative, jlong, newCopyOfBrushCoat)
+(JNIEnv* env, jobject object, jlong native_pointer, jint index) {
+  const BrushFamily& brush_family = CastToBrushFamily(native_pointer);
+  return reinterpret_cast<jlong>(new BrushCoat(brush_family.GetCoats()[index]));
+}
+
 }  // extern "C"

ink/brush/internal/jni/brush_jni.cc

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2024-2025 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -30,11 +30,11 @@ namespace {
 
 using ::ink::Brush;
 using ::ink::BrushFamily;
-using ::ink::CastToBrush;
-using ::ink::CastToBrushFamily;
 using ::ink::Color;
 using ::ink::ColorSpace;
 using ::ink::Color::Format::kGammaEncoded;
+using ::ink::jni::CastToBrush;
+using ::ink::jni::CastToBrushFamily;
 using ::ink::jni::ColorSpaceIsSupportedInJetpack;
 using ::ink::jni::ColorSpaceToJInt;
 using ::ink::jni::JIntToColorSpace;

ink/brush/internal/jni/brush_jni_helper.h

@@ -1,4 +1,4 @@
-// Copyright 2024 Google LLC
+// Copyright 2024-2025 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -17,56 +17,62 @@
 
 #include <jni.h>
 
-#include <string>
-
 #include "ink/brush/brush.h"
 #include "ink/brush/brush_behavior.h"
 #include "ink/brush/brush_coat.h"
 #include "ink/brush/brush_family.h"
 #include "ink/brush/brush_paint.h"
 #include "ink/brush/brush_tip.h"
 
-namespace ink {
+namespace ink::jni {
 
 // Casts a Kotlin Brush.nativePointer to a C++ Brush. The returned
-// Brush is a const ref as the kotlin Brush is immutable.
-inline const ink::Brush& CastToBrush(jlong brush_native_pointer) {
-  return *reinterpret_cast<ink::Brush*>(brush_native_pointer);
+// Brush is a const ref as the Kotlin Brush is immutable.
+inline const Brush& CastToBrush(jlong brush_native_pointer) {
+  return *reinterpret_cast<Brush*>(brush_native_pointer);
 }
 
 // Casts a Kotlin BrushFamily.nativePointer to a C++ BrushFamily. The returned
-// BrushFamily is a const ref as the kotlin BrushFamily is immutable.
-inline const ink::BrushFamily& CastToBrushFamily(
-    jlong brush_family_native_pointer) {
-  return *reinterpret_cast<ink::BrushFamily*>(brush_family_native_pointer);
+// BrushFamily is a const ref as the Kotlin BrushFamily is immutable.
+inline const BrushFamily& CastToBrushFamily(jlong brush_family_native_pointer) {
+  return *reinterpret_cast<BrushFamily*>(brush_family_native_pointer);
 }
 
 // Casts a Kotlin BrushCoat.nativePointer to a C++ BrushCoat. The returned
-// BrushCoat is a const ref as the kotlin BrushCoat is immutable.
-inline const ink::BrushCoat& CastToBrushCoat(jlong brush_coat_native_pointer) {
-  return *reinterpret_cast<ink::BrushCoat*>(brush_coat_native_pointer);
+// BrushCoat is a const ref as the Kotlin BrushCoat is immutable.
+inline const BrushCoat& CastToBrushCoat(jlong brush_coat_native_pointer) {
+  return *reinterpret_cast<BrushCoat*>(brush_coat_native_pointer);
 }
 
 // Casts a Kotlin BrushPaint.nativePointer to a C++ BrushPaint. The returned
-// BrushPaint is a const ref as the kotlin BrushPaint is immutable.
-inline const ink::BrushPaint& CastToBrushPaint(
-    jlong brush_paint_native_pointer) {
-  return *reinterpret_cast<ink::BrushPaint*>(brush_paint_native_pointer);
+// BrushPaint is a const ref as the Kotlin BrushPaint is immutable.
+inline const BrushPaint& CastToBrushPaint(jlong brush_paint_native_pointer) {
+  return *reinterpret_cast<BrushPaint*>(brush_paint_native_pointer);
+}
+
+// Casts a Kotlin BrushBehavior.nativePointer to a C++ BrushPaint::TextureLayer.
+// The returned TextureLayer is a const ref as the Kotlin BrushPaint is
+// immutable.
+inline const BrushPaint::TextureLayer& CastToTextureLayer(
+    jlong texture_layer_native_pointer) {
+  return *reinterpret_cast<BrushPaint::TextureLayer*>(
+      texture_layer_native_pointer);
 }
 
 // Casts a Kotlin BrushTip.nativePointer to a C++ BrushTip. The returned
-// BrushTip is a const ref as the kotlin BrushTip is immutable.
-inline const ink::BrushTip& CastToBrushTip(jlong brush_tip_native_pointer) {
-  return *reinterpret_cast<ink::BrushTip*>(brush_tip_native_pointer);
+// BrushTip is a const ref as the Kotlin BrushTip is immutable.
+inline const BrushTip& CastToBrushTip(jlong brush_tip_native_pointer) {
+  return *reinterpret_cast<BrushTip*>(brush_tip_native_pointer);
 }
 
 // Casts a Kotlin BrushBehavior.nativePointer to a C++ BrushBehavior. The
-// returned BrushBehavior is a const ref as the kotlin BrushBehavior is
+// returned BrushBehavior is a const ref as the Kotlin BrushBehavior is
 // immutable.
-inline const ink::BrushBehavior& CastToBrushBehavior(
+inline const BrushBehavior& CastToBrushBehavior(
     jlong brush_behavior_native_pointer) {
-  return *reinterpret_cast<ink::BrushBehavior*>(brush_behavior_native_pointer);
+  return *reinterpret_cast<BrushBehavior*>(brush_behavior_native_pointer);
 }
 
-}  // namespace ink
+}  // namespace ink::jni
+
 #endif  // INK_STROKES_BRUSH_INTERNAL_JNI_BRUSH_JNI_HELPER_H_