Migrate ABSL_INTERNAL_ATTRIBUTE_OWNER and ABSL_INTERNAL_ATTRIBUTE_VIEW to…

Migrate ABSL_INTERNAL_ATTRIBUTE_OWNER and ABSL_INTERNAL_ATTRIBUTE_VIEW to ABSL_ATTRIBUTE_OWNER and ABSL_ATTRIBUTE_VIEW

PiperOrigin-RevId: 666390885
Change-Id: I85457d39cf5ecb1c6622c6d59cb1876b154d64c3

absl/container/btree_map.h

@@ -87,7 +87,7 @@ struct map_params;
 //
 //
 template <typename Key, typename Value, typename Compare = std::less<Key>,
 template <typename Key, typename Value, typename Compare = std::less<Key>,
           typename Alloc = std::allocator<std::pair<const Key, Value>>>
           typename Alloc = std::allocator<std::pair<const Key, Value>>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER btree_map
+class ABSL_ATTRIBUTE_OWNER btree_map
     : public container_internal::btree_map_container<
     : public container_internal::btree_map_container<
           container_internal::btree<container_internal::map_params<
           container_internal::btree<container_internal::map_params<
               Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
               Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
@@ -525,7 +525,7 @@ typename btree_map<K, V, C, A>::size_type erase_if(
 //
 //
 template <typename Key, typename Value, typename Compare = std::less<Key>,
 template <typename Key, typename Value, typename Compare = std::less<Key>,
           typename Alloc = std::allocator<std::pair<const Key, Value>>>
           typename Alloc = std::allocator<std::pair<const Key, Value>>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER btree_multimap
+class ABSL_ATTRIBUTE_OWNER btree_multimap
     : public container_internal::btree_multimap_container<
     : public container_internal::btree_multimap_container<
           container_internal::btree<container_internal::map_params<
           container_internal::btree<container_internal::map_params<
               Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,
               Key, Value, Compare, Alloc, /*TargetNodeSize=*/256,

absl/container/btree_set.h

@@ -89,7 +89,7 @@ struct set_params;
 //
 //
 template <typename Key, typename Compare = std::less<Key>,
 template <typename Key, typename Compare = std::less<Key>,
           typename Alloc = std::allocator<Key>>
           typename Alloc = std::allocator<Key>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER btree_set
+class ABSL_ATTRIBUTE_OWNER btree_set
     : public container_internal::btree_set_container<
     : public container_internal::btree_set_container<
           container_internal::btree<container_internal::set_params<
           container_internal::btree<container_internal::set_params<
               Key, Compare, Alloc, /*TargetNodeSize=*/256,
               Key, Compare, Alloc, /*TargetNodeSize=*/256,
@@ -445,7 +445,7 @@ typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A> &set,
 //
 //
 template <typename Key, typename Compare = std::less<Key>,
 template <typename Key, typename Compare = std::less<Key>,
           typename Alloc = std::allocator<Key>>
           typename Alloc = std::allocator<Key>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER btree_multiset
+class ABSL_ATTRIBUTE_OWNER btree_multiset
     : public container_internal::btree_multiset_container<
     : public container_internal::btree_multiset_container<
           container_internal::btree<container_internal::set_params<
           container_internal::btree<container_internal::set_params<
               Key, Compare, Alloc, /*TargetNodeSize=*/256,
               Key, Compare, Alloc, /*TargetNodeSize=*/256,

absl/container/flat_hash_map.h

@@ -125,7 +125,7 @@ struct FlatHashMapPolicy;
 template <class K, class V, class Hash = DefaultHashContainerHash<K>,
 template <class K, class V, class Hash = DefaultHashContainerHash<K>,
           class Eq = DefaultHashContainerEq<K>,
           class Eq = DefaultHashContainerEq<K>,
           class Allocator = std::allocator<std::pair<const K, V>>>
           class Allocator = std::allocator<std::pair<const K, V>>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER flat_hash_map
+class ABSL_ATTRIBUTE_OWNER flat_hash_map
     : public absl::container_internal::raw_hash_map<
     : public absl::container_internal::raw_hash_map<
           absl::container_internal::FlatHashMapPolicy<K, V>, Hash, Eq,
           absl::container_internal::FlatHashMapPolicy<K, V>, Hash, Eq,
           Allocator> {
           Allocator> {

absl/container/flat_hash_set.h

@@ -122,7 +122,7 @@ struct FlatHashSetPolicy;
 template <class T, class Hash = DefaultHashContainerHash<T>,
 template <class T, class Hash = DefaultHashContainerHash<T>,
           class Eq = DefaultHashContainerEq<T>,
           class Eq = DefaultHashContainerEq<T>,
           class Allocator = std::allocator<T>>
           class Allocator = std::allocator<T>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER flat_hash_set
+class ABSL_ATTRIBUTE_OWNER flat_hash_set
     : public absl::container_internal::raw_hash_set<
     : public absl::container_internal::raw_hash_set<
           absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
           absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
   using Base = typename flat_hash_set::raw_hash_set;
   using Base = typename flat_hash_set::raw_hash_set;

absl/container/node_hash_map.h

@@ -120,7 +120,7 @@ class NodeHashMapPolicy;
 template <class Key, class Value, class Hash = DefaultHashContainerHash<Key>,
 template <class Key, class Value, class Hash = DefaultHashContainerHash<Key>,
           class Eq = DefaultHashContainerEq<Key>,
           class Eq = DefaultHashContainerEq<Key>,
           class Alloc = std::allocator<std::pair<const Key, Value>>>
           class Alloc = std::allocator<std::pair<const Key, Value>>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER node_hash_map
+class ABSL_ATTRIBUTE_OWNER node_hash_map
     : public absl::container_internal::raw_hash_map<
     : public absl::container_internal::raw_hash_map<
           absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq,
           absl::container_internal::NodeHashMapPolicy<Key, Value>, Hash, Eq,
           Alloc> {
           Alloc> {

absl/container/node_hash_set.h

@@ -115,7 +115,7 @@ struct NodeHashSetPolicy;
 //  }
 //  }
 template <class T, class Hash = DefaultHashContainerHash<T>,
 template <class T, class Hash = DefaultHashContainerHash<T>,
           class Eq = DefaultHashContainerEq<T>, class Alloc = std::allocator<T>>
           class Eq = DefaultHashContainerEq<T>, class Alloc = std::allocator<T>>
-class ABSL_INTERNAL_ATTRIBUTE_OWNER node_hash_set
+class ABSL_ATTRIBUTE_OWNER node_hash_set
     : public absl::container_internal::raw_hash_set<
     : public absl::container_internal::raw_hash_set<
           absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> {
           absl::container_internal::NodeHashSetPolicy<T>, Hash, Eq, Alloc> {
   using Base = typename node_hash_set::raw_hash_set;
   using Base = typename node_hash_set::raw_hash_set;

absl/strings/string_view.h

@@ -159,7 +159,7 @@ ABSL_NAMESPACE_BEGIN
 //
 //
 //   absl::string_view() == absl::string_view("", 0)
 //   absl::string_view() == absl::string_view("", 0)
 //   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
 //   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
-class ABSL_INTERNAL_ATTRIBUTE_VIEW string_view {
+class ABSL_ATTRIBUTE_VIEW string_view {
  public:
  public:
   using traits_type = std::char_traits<char>;
   using traits_type = std::char_traits<char>;
   using value_type = char;
   using value_type = char;

absl/types/span.h

@@ -151,7 +151,7 @@ ABSL_NAMESPACE_BEGIN
 //   int* my_array = new int[10];
 //   int* my_array = new int[10];
 //   MyRoutine(absl::Span<const int>(my_array, 10));
 //   MyRoutine(absl::Span<const int>(my_array, 10));
 template <typename T>
 template <typename T>
-class ABSL_INTERNAL_ATTRIBUTE_VIEW Span {
+class ABSL_ATTRIBUTE_VIEW Span {
  private:
  private:
   // Used to determine whether a Span can be constructed from a container of
   // Used to determine whether a Span can be constructed from a container of
   // type C.
   // type C.