Document that the domain objects are not thread-safe.

PiperOrigin-RevId: 792730547

Author: hadi88

fuzztest/internal/domains/domain.h

@@ -65,7 +65,9 @@ struct GenericPrinter {
 // `Domain<T>` is the type-erased domain interface.
 //
 // It can be constructed from any object derived from `DomainBase` that
-// implements the domain methods for the value type `T`.
+// implements the domain methods for the value type `T`. A Domain object is not
+// thread-safe. It's the domain object owner's responsibility to make sure the
+// domain object is not accessed concurrently by multiple threads.
 template <typename T>
 class Domain {
  public:

fuzztest/internal/domains/protobuf_domain_impl.h

@@ -349,12 +349,13 @@ class ProtoPolicy {
       const ProtoDescriptor* descriptor) {
     ABSL_CONST_INIT static absl::Mutex mutex(absl::kConstInit);
     static absl::NoDestructor<absl::flat_hash_map<
-        const ProtoDescriptor*, std::vector<const FieldDescriptor*>>>
+        const ProtoDescriptor*,
+        std::unique_ptr<std::vector<const FieldDescriptor*>>>>
         descriptor_to_fields ABSL_GUARDED_BY(mutex);
     {
       absl::MutexLock l(&mutex);
       auto it = descriptor_to_fields->find(descriptor);
-      if (it != descriptor_to_fields->end()) return it->second;
+      if (it != descriptor_to_fields->end()) return *(it->second);
     }
     std::vector<const FieldDescriptor*> fields;
     fields.reserve(descriptor->field_count());
@@ -365,9 +366,10 @@ class ProtoPolicy {
     if (ShouldEnumerateExtensions(descriptor)) {
       descriptor->file()->pool()->FindAllExtensions(descriptor, &fields);
     }
-    auto [it, _] =
-        descriptor_to_fields->insert({descriptor, std::move(fields)});
-    return it->second;
+    auto [it, _] = descriptor_to_fields->insert(
+        {descriptor, std::make_unique<std::vector<const FieldDescriptor*>>(
+                         std::move(fields))});
+    return *(it->second);
   }
 
  private:
@@ -408,12 +410,10 @@ class ProtoPolicy {
   class RecursiveFieldsCaches {
    public:
     void SetIsFieldFinitelyRecursive(const FieldDescriptor* field, bool value) {
-      absl::MutexLock l(&field_to_is_finitely_recursive_mutex_);
       field_to_is_finitely_recursive_.insert({field, value});
     }
 
     std::optional<bool> IsFieldFinitelyRecursive(const FieldDescriptor* field) {
-      absl::ReaderMutexLock l(&field_to_is_finitely_recursive_mutex_);
       auto it = field_to_is_finitely_recursive_.find(field);
       return it != field_to_is_finitely_recursive_.end()
                  ? std::optional(it->second)
@@ -422,13 +422,11 @@ class ProtoPolicy {
 
     void SetIsFieldInfinitelyRecursive(const FieldDescriptor* field,
                                        bool value) {
-      absl::MutexLock l(&field_to_is_infinitely_recursive_mutex_);
       field_to_is_infinitely_recursive_.insert({field, value});
     }
 
     std::optional<bool> IsFieldInfinitelyRecursive(
         const FieldDescriptor* field) {
-      absl::ReaderMutexLock l(&field_to_is_infinitely_recursive_mutex_);
       auto it = field_to_is_infinitely_recursive_.find(field);
       return it != field_to_is_infinitely_recursive_.end()
                  ? std::optional(it->second)
@@ -437,32 +435,27 @@ class ProtoPolicy {
 
     const std::vector<const FieldDescriptor*>* GetFields(
         const ProtoDescriptor* descriptor) {
-      absl::ReaderMutexLock l(&proto_to_fields_mutex_);
       auto it = proto_to_fields_.find(descriptor);
-      return it != proto_to_fields_.end() ? &it->second : nullptr;
+      return it != proto_to_fields_.end() ? it->second.get() : nullptr;
     }
 
     const std::vector<const FieldDescriptor*>& SetFields(
         const ProtoDescriptor* descriptor,
         std::vector<const FieldDescriptor*> fields) {
-      absl::MutexLock l(&proto_to_fields_mutex_);
-      auto [it, _] = proto_to_fields_.insert({descriptor, std::move(fields)});
-      return it->second;
+      auto [it, _] = proto_to_fields_.insert(
+          {descriptor, std::make_unique<std::vector<const FieldDescriptor*>>(
+                           std::move(fields))});
+      return *it->second;
     }
 
    private:
-    absl::Mutex field_to_is_finitely_recursive_mutex_;
     absl::flat_hash_map<const FieldDescriptor*, bool>
-        field_to_is_finitely_recursive_
-            ABSL_GUARDED_BY(field_to_is_finitely_recursive_mutex_);
-    absl::Mutex field_to_is_infinitely_recursive_mutex_;
+        field_to_is_finitely_recursive_;
     absl::flat_hash_map<const FieldDescriptor*, bool>
-        field_to_is_infinitely_recursive_
-            ABSL_GUARDED_BY(field_to_is_infinitely_recursive_mutex_);
-    absl::Mutex proto_to_fields_mutex_;
+        field_to_is_infinitely_recursive_;
     absl::flat_hash_map<const ProtoDescriptor*,
-                        std::vector<const FieldDescriptor*>>
-        proto_to_fields_ ABSL_GUARDED_BY(proto_to_fields_mutex_);
+                        std::unique_ptr<std::vector<const FieldDescriptor*>>>
+        proto_to_fields_;
   };
 
   std::shared_ptr<RecursiveFieldsCaches> caches_ = nullptr;
@@ -601,7 +594,6 @@ class ProtobufDomainUntypedImpl
   ProtobufDomainUntypedImpl(const ProtobufDomainUntypedImpl& other)
       : prototype_(other.prototype_),
         use_lazy_initialization_(other.use_lazy_initialization_) {
-    absl::MutexLock l(&other.mutex_);
     domains_ = other.domains_;
     policy_ = other.policy_;
     customized_fields_ = other.customized_fields_;
@@ -1432,7 +1424,6 @@ class ProtobufDomainUntypedImpl
               "` but the field needs a message of type `",
               field->message_type()->full_name(), "`.");
         }
-        absl::MutexLock l(&self.mutex_);
         auto res = self.domains_.try_emplace(field->number(),
                                              std::in_place_type<DomainT>,
                                              std::forward<Inner>(domain));
@@ -1694,7 +1685,6 @@ class ProtobufDomainUntypedImpl
     using DomainT = decltype(GetDefaultDomainForField<T, is_repeated>(field));
     // Do the operation under a lock to prevent race conditions in `const`
     // methods.
-    absl::MutexLock l(&mutex_);
     auto it = domains_.find(field->number());
     if (it == domains_.end()) {
       it = domains_
@@ -2019,9 +2009,7 @@ class ProtobufDomainUntypedImpl
   PrototypePtr<Message> prototype_;
   bool use_lazy_initialization_;
 
-  mutable absl::Mutex mutex_;
-  mutable absl::flat_hash_map<int, CopyableAny> domains_
-      ABSL_GUARDED_BY(mutex_);
+  mutable absl::flat_hash_map<int, CopyableAny> domains_;
 
   ProtoPolicy<Message> policy_;
   absl::flat_hash_set<int> customized_fields_;