grpc 1.45.0 → 1.53.0

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_navigator.cc

@@ -16,6 +16,7 @@
 
 #include <cassert>
 
+#include "absl/strings/internal/cord_data_edge.h"
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
 
@@ -39,7 +40,7 @@ inline CordRep* Substring(CordRep* rep, size_t offset, size_t n) {
   assert(n <= rep->length);
   assert(offset < rep->length);
   assert(offset <= rep->length - n);
-  assert(CordRepBtree::IsDataEdge(rep));
+  assert(IsDataEdge(rep));
 
   if (n == 0) return nullptr;
   if (n == rep->length) return CordRep::Ref(rep);
@@ -49,6 +50,7 @@ inline CordRep* Substring(CordRep* rep, size_t offset, size_t n) {
     rep = rep->substring()->child;
   }
 
+  assert(rep->IsExternal() || rep->IsFlat());
   CordRepSubstring* substring = new CordRepSubstring();
   substring->length = n;
   substring->tag = SUBSTRING;
@@ -88,7 +90,7 @@ CordRepBtreeNavigator::Position CordRepBtreeNavigator::Skip(size_t n) {
   // edges that must be skipped.
   while (height > 0) {
     node = edge->btree();
-    index_[height] = index;
+    index_[height] = static_cast<uint8_t>(index);
     node_[--height] = node;
     index = node->begin();
     edge = node->Edge(index);
@@ -99,7 +101,7 @@ CordRepBtreeNavigator::Position CordRepBtreeNavigator::Skip(size_t n) {
       edge = node->Edge(index);
     }
   }
-  index_[0] = index;
+  index_[0] = static_cast<uint8_t>(index);
   return {edge, n};
 }
 
@@ -124,7 +126,7 @@ ReadResult CordRepBtreeNavigator::Read(size_t edge_offset, size_t n) {
   do {
     length -= edge->length;
     while (++index == node->end()) {
-      index_[height] = index;
+      index_[height] = static_cast<uint8_t>(index);
       if (++height > height_) {
         subtree->set_end(subtree_end);
         if (length == 0) return {subtree, 0};
@@ -152,7 +154,7 @@ ReadResult CordRepBtreeNavigator::Read(size_t edge_offset, size_t n) {
   // edges that must be read, adding 'down' nodes to `subtree`.
   while (height > 0) {
     node = edge->btree();
-    index_[height] = index;
+    index_[height] = static_cast<uint8_t>(index);
     node_[--height] = node;
     index = node->begin();
     edge = node->Edge(index);
@@ -176,7 +178,7 @@ ReadResult CordRepBtreeNavigator::Read(size_t edge_offset, size_t n) {
     subtree->edges_[subtree_end++] = Substring(edge, 0, length);
   }
   subtree->set_end(subtree_end);
-  index_[0] = index;
+  index_[0] = static_cast<uint8_t>(index);
   return {tree, length};
 }
 

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_navigator.h

@@ -143,8 +143,8 @@ class CordRepBtreeNavigator {
   // `index_` and `node_` contain the navigation state as the 'path' to the
   // current data edge which is at `node_[0]->Edge(index_[0])`. The contents
   // of these are undefined until the instance is initialized (`height_ >= 0`).
-  uint8_t index_[CordRepBtree::kMaxHeight];
-  CordRepBtree* node_[CordRepBtree::kMaxHeight];
+  uint8_t index_[CordRepBtree::kMaxDepth];
+  CordRepBtree* node_[CordRepBtree::kMaxDepth];
 };
 
 // Returns true if this instance is not empty.
@@ -173,6 +173,7 @@ template <CordRepBtree::EdgeType edge_type>
 inline CordRep* CordRepBtreeNavigator::Init(CordRepBtree* tree) {
   assert(tree != nullptr);
   assert(tree->size() > 0);
+  assert(tree->height() <= CordRepBtree::kMaxHeight);
   int height = height_ = tree->height();
   size_t index = tree->index(edge_type);
   node_[height] = tree;
@@ -206,6 +207,7 @@ inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
 inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::InitOffset(
     CordRepBtree* tree, size_t offset) {
   assert(tree != nullptr);
+  assert(tree->height() <= CordRepBtree::kMaxHeight);
   if (ABSL_PREDICT_FALSE(offset >= tree->length)) return {nullptr, 0};
   height_ = tree->height();
   node_[height_] = tree;

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_reader.cc

@@ -17,6 +17,7 @@
 #include <cassert>
 
 #include "absl/base/config.h"
+#include "absl/strings/internal/cord_data_edge.h"
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
 #include "absl/strings/internal/cord_rep_btree_navigator.h"
@@ -44,7 +45,7 @@ absl::string_view CordRepBtreeReader::Read(size_t n, size_t chunk_size,
   // can directly return the substring into the current data edge as the next
   // chunk. We can easily establish from the above code that `navigator_.Next()`
   // has not been called as that requires `chunk_size` to be zero.
-  if (n < chunk_size) return CordRepBtree::EdgeData(edge).substr(result.n);
+  if (n < chunk_size) return EdgeData(edge).substr(result.n);
 
   // The amount of data taken from the last edge is `chunk_size` and `result.n`
   // contains the offset into the current edge trailing the read data (which can
@@ -60,7 +61,7 @@ absl::string_view CordRepBtreeReader::Read(size_t n, size_t chunk_size,
   // We did not read all data, return remaining data from current edge.
   edge = navigator_.Current();
   remaining_ -= consumed_by_read + edge->length;
-  return CordRepBtree::EdgeData(edge).substr(result.n);
+  return EdgeData(edge).substr(result.n);
 }
 
 }  // namespace cord_internal

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_reader.h

@@ -18,6 +18,7 @@
 #include <cassert>
 
 #include "absl/base/config.h"
+#include "absl/strings/internal/cord_data_edge.h"
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
 #include "absl/strings/internal/cord_rep_btree_navigator.h"
@@ -167,7 +168,7 @@ inline absl::string_view CordRepBtreeReader::Init(CordRepBtree* tree) {
   assert(tree != nullptr);
   const CordRep* edge = navigator_.InitFirst(tree);
   remaining_ = tree->length - edge->length;
-  return CordRepBtree::EdgeData(edge);
+  return EdgeData(edge);
 }
 
 inline absl::string_view CordRepBtreeReader::Next() {
@@ -175,7 +176,7 @@ inline absl::string_view CordRepBtreeReader::Next() {
   const CordRep* edge = navigator_.Next();
   assert(edge != nullptr);
   remaining_ -= edge->length;
-  return CordRepBtree::EdgeData(edge);
+  return EdgeData(edge);
 }
 
 inline absl::string_view CordRepBtreeReader::Skip(size_t skip) {
@@ -190,7 +191,7 @@ inline absl::string_view CordRepBtreeReader::Skip(size_t skip) {
   // The combined length of all edges skipped before `pos.edge` is `skip -
   // pos.offset`, all of which are 'consumed', as well as the current edge.
   remaining_ -= skip - pos.offset + pos.edge->length;
-  return CordRepBtree::EdgeData(pos.edge).substr(pos.offset);
+  return EdgeData(pos.edge).substr(pos.offset);
 }
 
 inline absl::string_view CordRepBtreeReader::Seek(size_t offset) {
@@ -199,7 +200,7 @@ inline absl::string_view CordRepBtreeReader::Seek(size_t offset) {
     remaining_ = 0;
     return {};
   }
-  absl::string_view chunk = CordRepBtree::EdgeData(pos.edge).substr(pos.offset);
+  absl::string_view chunk = EdgeData(pos.edge).substr(pos.offset);
   remaining_ = length() - offset - chunk.length();
   return chunk;
 }

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_consume.cc

@@ -40,88 +40,21 @@ CordRep* ClipSubstring(CordRepSubstring* substring) {
   return child;
 }
 
-// Unrefs the provided `concat`, and returns `{concat->left, concat->right}`
-// Adds or assumes a reference on `concat->left` and `concat->right`.
-// Returns an array of 2 elements containing the left and right nodes.
-std::array<CordRep*, 2> ClipConcat(CordRepConcat* concat) {
-  std::array<CordRep*, 2> result{concat->left, concat->right};
-  if (concat->refcount.IsOne()) {
-    delete concat;
-  } else {
-    CordRep::Ref(result[0]);
-    CordRep::Ref(result[1]);
-    CordRep::Unref(concat);
-  }
-  return result;
-}
+}  // namespace
 
-void Consume(bool forward, CordRep* rep, ConsumeFn consume_fn) {
+void Consume(CordRep* rep, ConsumeFn consume_fn) {
   size_t offset = 0;
   size_t length = rep->length;
-  struct Entry {
-    CordRep* rep;
-    size_t offset;
-    size_t length;
-  };
-  absl::InlinedVector<Entry, 40> stack;
-
-  for (;;) {
-    if (rep->tag == CONCAT) {
-      std::array<CordRep*, 2> res = ClipConcat(rep->concat());
-      CordRep* left = res[0];
-      CordRep* right = res[1];
-
-      if (left->length <= offset) {
-        // Don't need left node
-        offset -= left->length;
-        CordRep::Unref(left);
-        rep = right;
-        continue;
-      }
 
-      size_t length_left = left->length - offset;
-      if (length_left >= length) {
-        // Don't need right node
-        CordRep::Unref(right);
-        rep = left;
-        continue;
-      }
-
-      // Need both nodes
-      size_t length_right = length - length_left;
-      if (forward) {
-        stack.push_back({right, 0, length_right});
-        rep = left;
-        length = length_left;
-      } else {
-        stack.push_back({left, offset, length_left});
-        rep = right;
-        offset = 0;
-        length = length_right;
-      }
-    } else if (rep->tag == SUBSTRING) {
-      offset += rep->substring()->start;
-      rep = ClipSubstring(rep->substring());
-    } else {
-      consume_fn(rep, offset, length);
-      if (stack.empty()) return;
-
-      rep = stack.back().rep;
-      offset = stack.back().offset;
-      length = stack.back().length;
-      stack.pop_back();
-    }
+  if (rep->tag == SUBSTRING) {
+    offset += rep->substring()->start;
+    rep = ClipSubstring(rep->substring());
   }
-}
-
-}  // namespace
-
-void Consume(CordRep* rep, ConsumeFn consume_fn) {
-  return Consume(true, rep, std::move(consume_fn));
+  consume_fn(rep, offset, length);
 }
 
 void ReverseConsume(CordRep* rep, ConsumeFn consume_fn) {
-  return Consume(false, rep, std::move(consume_fn));
+  return Consume(rep, std::move(consume_fn));
 }
 
 }  // namespace cord_internal

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_crc.cc

@@ -0,0 +1,56 @@
+// Copyright 2021 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/cord_rep_crc.h"
+
+#include <cassert>
+#include <cstdint>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+CordRepCrc* CordRepCrc::New(CordRep* child, crc_internal::CrcCordState state) {
+  if (child != nullptr && child->IsCrc()) {
+    if (child->refcount.IsOne()) {
+      child->crc()->crc_cord_state = std::move(state);
+      return child->crc();
+    }
+    CordRep* old = child;
+    child = old->crc()->child;
+    CordRep::Ref(child);
+    CordRep::Unref(old);
+  }
+  auto* new_cordrep = new CordRepCrc;
+  new_cordrep->length = child != nullptr ? child->length : 0;
+  new_cordrep->tag = cord_internal::CRC;
+  new_cordrep->child = child;
+  new_cordrep->crc_cord_state = std::move(state);
+  return new_cordrep;
+}
+
+void CordRepCrc::Destroy(CordRepCrc* node) {
+  if (node->child != nullptr) {
+    CordRep::Unref(node->child);
+  }
+  delete node;
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_crc.h

@@ -0,0 +1,103 @@
+// Copyright 2021 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
+
+#include <cassert>
+#include <cstdint>
+
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+#include "absl/crc/internal/crc_cord_state.h"
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepCrc is a CordRep node intended only to appear at the top level of a
+// cord tree.  It associates an "expected CRC" with the contained data, to allow
+// for easy passage of checksum data in Cord data flows.
+//
+// From Cord's perspective, the crc value has no semantics; any validation of
+// the contained checksum is the user's responsibility.
+struct CordRepCrc : public CordRep {
+  CordRep* child;
+  absl::crc_internal::CrcCordState crc_cord_state;
+
+  // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
+  // If the specified `child` is itself a CordRepCrc node, then this method
+  // either replaces the existing node, or directly updates the crc state in it
+  // depending on the node being shared or not, i.e.: refcount.IsOne().
+  // `child` must only be null if the Cord is empty. Never returns null.
+  static CordRepCrc* New(CordRep* child, crc_internal::CrcCordState state);
+
+  // Destroys (deletes) the provided node. `node` must not be null.
+  static void Destroy(CordRepCrc* node);
+};
+
+// Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
+// removed.  This is usually a no-op (returning `rep`), but this will remove and
+// unref an outer CordRepCrc node.
+inline CordRep* RemoveCrcNode(CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    CordRep* child = rep->crc()->child;
+    if (rep->refcount.IsOne()) {
+      delete rep->crc();
+    } else {
+      CordRep::Ref(child);
+      CordRep::Unref(rep);
+    }
+    return child;
+  }
+  return rep;
+}
+
+// Returns `rep` if it is not a CordRepCrc node, or its child if it is.
+// Does not consume or create a reference on `rep` or the returned value.
+inline CordRep* SkipCrcNode(CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    return rep->crc()->child;
+  } else {
+    return rep;
+  }
+}
+
+inline const CordRep* SkipCrcNode(const CordRep* rep) {
+  assert(rep != nullptr);
+  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
+    return rep->crc()->child;
+  } else {
+    return rep;
+  }
+}
+
+inline CordRepCrc* CordRep::crc() {
+  assert(IsCrc());
+  return static_cast<CordRepCrc*>(this);
+}
+
+inline const CordRepCrc* CordRep::crc() const {
+  assert(IsCrc());
+  return static_cast<const CordRepCrc*>(this);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_flat.h

@@ -20,6 +20,8 @@
 #include <cstdint>
 #include <memory>
 
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
 #include "absl/strings/internal/cord_internal.h"
 
 namespace absl {
@@ -42,23 +44,45 @@ static constexpr size_t kMinFlatSize = 32;
 static constexpr size_t kMaxFlatSize = 4096;
 static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
 static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
+static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
+static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
 
+// kTagBase should make the Size <--> Tag computation resilient
+// against changes to the value of FLAT when we add a new tag..
+static constexpr uint8_t kTagBase = FLAT - 4;
+
+// Converts the provided rounded size to the corresponding tag
 constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
-  return static_cast<uint8_t>((size <= 1024) ? size / 8 + 1
-                                             : 129 + size / 32 - 1024 / 32);
+  return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8
+                              : size <= 8192
+                                  ? kTagBase + 512 / 8 + size / 64 - 512 / 64
+                                  : kTagBase + 512 / 8 + ((8192 - 512) / 64) +
+                                        size / 4096 - 8192 / 4096);
+}
+
+// Converts the provided tag to the corresponding allocated size
+constexpr size_t TagToAllocatedSize(uint8_t tag) {
+  return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8
+         : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64))
+             ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64
+             : 8192 + tag * 4096 - kTagBase * 4096 -
+                   ((512 / 8) + ((8192 - 512) / 64)) * 4096;
 }
 
-static_assert(kMinFlatSize / 8 + 1 >= FLAT, "");
-static_assert(AllocatedSizeToTagUnchecked(kMaxFlatSize) <= MAX_FLAT_TAG, "");
+static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
+static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG,
+              "");
 
-// Helper functions for rounded div, and rounding to exact sizes.
-constexpr size_t DivUp(size_t n, size_t m) { return (n + m - 1) / m; }
-constexpr size_t RoundUp(size_t n, size_t m) { return DivUp(n, m) * m; }
+// RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
+// multiple of `m`, optimized for the invariant that `m` is a power of 2.
+constexpr size_t RoundUp(size_t n, size_t m) {
+  return (n + m - 1) & (0 - m);
+}
 
 // Returns the size to the nearest equal or larger value that can be
 // expressed exactly as a tag value.
 inline size_t RoundUpForTag(size_t size) {
-  return RoundUp(size, (size <= 1024) ? 8 : 32);
+  return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
 }
 
 // Converts the allocated size to a tag, rounding down if the size
@@ -71,26 +95,26 @@ inline uint8_t AllocatedSizeToTag(size_t size) {
   return tag;
 }
 
-// Converts the provided tag to the corresponding allocated size
-constexpr size_t TagToAllocatedSize(uint8_t tag) {
-  return (tag <= 129) ? ((tag - 1) * 8) : (1024 + (tag - 129) * 32);
-}
-
 // Converts the provided tag to the corresponding available data length
 constexpr size_t TagToLength(uint8_t tag) {
   return TagToAllocatedSize(tag) - kFlatOverhead;
 }
 
 // Enforce that kMaxFlatSize maps to a well-known exact tag value.
-static_assert(TagToAllocatedSize(225) == kMaxFlatSize, "Bad tag logic");
+static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize,
+              "Bad tag logic");
 
 struct CordRepFlat : public CordRep {
+  // Tag for explicit 'large flat' allocation
+  struct Large {};
+
   // Creates a new flat node.
-  static CordRepFlat* New(size_t len) {
+  template <size_t max_flat_size, typename... Args>
+  static CordRepFlat* NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED) {
     if (len <= kMinFlatLength) {
       len = kMinFlatLength;
-    } else if (len > kMaxFlatLength) {
-      len = kMaxFlatLength;
+    } else if (len > max_flat_size - kFlatOverhead) {
+      len = max_flat_size - kFlatOverhead;
     }
 
     // Round size up so it matches a size we can exactly express in a tag.
@@ -101,6 +125,12 @@ struct CordRepFlat : public CordRep {
     return rep;
   }
 
+  static CordRepFlat* New(size_t len) { return NewImpl<kMaxFlatSize>(len); }
+
+  static CordRepFlat* New(Large, size_t len) {
+    return NewImpl<kMaxLargeFlatSize>(len);
+  }
+
   // Deletes a CordRepFlat instance created previously through a call to New().
   // Flat CordReps are allocated and constructed with raw ::operator new and
   // placement new, and must be destructed and deallocated accordingly.
@@ -117,6 +147,17 @@ struct CordRepFlat : public CordRep {
 #endif
   }
 
+  // Create a CordRepFlat containing `data`, with an optional additional
+  // extra capacity of up to `extra` bytes. Requires that `data.size()`
+  // is less than kMaxFlatLength.
+  static CordRepFlat* Create(absl::string_view data, size_t extra = 0) {
+    assert(data.size() <= kMaxFlatLength);
+    CordRepFlat* flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
+    memcpy(flat->Data(), data.data(), data.size());
+    flat->length = data.size();
+    return flat;
+  }
+
   // Returns a pointer to the data inside this flat rep.
   char* Data() { return reinterpret_cast<char*>(storage); }
   const char* Data() const { return reinterpret_cast<const char*>(storage); }

data/third_party/abseil-cpp/absl/strings/internal/cord_rep_ring.cc

@@ -129,7 +129,9 @@ class CordRepRing::Filler {
   index_type pos_;
 };
 
-constexpr size_t CordRepRing::kMaxCapacity; // NOLINT: needed for c++11
+#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+constexpr size_t CordRepRing::kMaxCapacity;
+#endif
 
 bool CordRepRing::IsValid(std::ostream& output) const {
   if (capacity_ == 0) {
@@ -277,7 +279,7 @@ CordRepRing* CordRepRing::Mutable(CordRepRing* rep, size_t extra) {
   // Get current number of entries, and check for max capacity.
   size_t entries = rep->entries();
 
-  if (!rep->refcount.IsMutable()) {
+  if (!rep->refcount.IsOne()) {
     return Copy(rep, rep->head(), rep->tail(), extra);
   } else if (entries + extra > rep->capacity()) {
     const size_t min_grow = rep->capacity() + rep->capacity() / 2;
@@ -292,10 +294,10 @@ CordRepRing* CordRepRing::Mutable(CordRepRing* rep, size_t extra) {
 }
 
 Span<char> CordRepRing::GetAppendBuffer(size_t size) {
-  assert(refcount.IsMutable());
+  assert(refcount.IsOne());
   index_type back = retreat(tail_);
   CordRep* child = entry_child(back);
-  if (child->tag >= FLAT && child->refcount.IsMutable()) {
+  if (child->tag >= FLAT && child->refcount.IsOne()) {
     size_t capacity = child->flat()->Capacity();
     pos_type end_pos = entry_end_pos(back);
     size_t data_offset = entry_data_offset(back);
@@ -312,10 +314,10 @@ Span<char> CordRepRing::GetAppendBuffer(size_t size) {
 }
 
 Span<char> CordRepRing::GetPrependBuffer(size_t size) {
-  assert(refcount.IsMutable());
+  assert(refcount.IsOne());
   CordRep* child = entry_child(head_);
   size_t data_offset = entry_data_offset(head_);
-  if (data_offset && child->refcount.IsMutable() && child->tag >= FLAT) {
+  if (data_offset && child->refcount.IsOne() && child->tag >= FLAT) {
     size_t n = (std::min)(data_offset, size);
     this->length += n;
     begin_pos_ -= n;
@@ -504,7 +506,7 @@ CordRepRing* CordRepRing::Prepend(CordRepRing* rep, CordRep* child) {
 
 CordRepRing* CordRepRing::Append(CordRepRing* rep, absl::string_view data,
                                  size_t extra) {
-  if (rep->refcount.IsMutable()) {
+  if (rep->refcount.IsOne()) {
     Span<char> avail = rep->GetAppendBuffer(data.length());
     if (!avail.empty()) {
       memcpy(avail.data(), data.data(), avail.length());
@@ -538,7 +540,7 @@ CordRepRing* CordRepRing::Append(CordRepRing* rep, absl::string_view data,
 
 CordRepRing* CordRepRing::Prepend(CordRepRing* rep, absl::string_view data,
                                   size_t extra) {
-  if (rep->refcount.IsMutable()) {
+  if (rep->refcount.IsOne()) {
     Span<char> avail = rep->GetPrependBuffer(data.length());
     if (!avail.empty()) {
       const char* tail = data.data() + data.length() - avail.length();
@@ -678,7 +680,7 @@ CordRepRing* CordRepRing::SubRing(CordRepRing* rep, size_t offset,
   Position tail = rep->FindTail(head.index, offset + len);
   const size_t new_entries = rep->entries(head.index, tail.index);
 
-  if (rep->refcount.IsMutable() && extra <= (rep->capacity() - new_entries)) {
+  if (rep->refcount.IsOne() && extra <= (rep->capacity() - new_entries)) {
     // We adopt a privately owned rep and no extra entries needed.
     if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index);
     if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_);
@@ -715,7 +717,7 @@ CordRepRing* CordRepRing::RemovePrefix(CordRepRing* rep, size_t len,
   }
 
   Position head = rep->Find(len);
-  if (rep->refcount.IsMutable()) {
+  if (rep->refcount.IsOne()) {
     if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index);
     rep->head_ = head.index;
   } else {
@@ -745,7 +747,7 @@ CordRepRing* CordRepRing::RemoveSuffix(CordRepRing* rep, size_t len,
   }
 
   Position tail = rep->FindTail(rep->length - len);
-  if (rep->refcount.IsMutable()) {
+  if (rep->refcount.IsOne()) {
     // We adopt a privately owned rep, scrub.
     if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_);
     rep->tail_ = tail.index;

data/third_party/abseil-cpp/absl/strings/internal/cordz_functions.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CORDZ_FUNCTIONS_H_
-#define ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#ifndef ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_
+#define ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_
 
 #include <stdint.h>
 
@@ -32,18 +32,10 @@ int32_t get_cordz_mean_interval();
 // Sets the sample rate with the average interval between samples.
 void set_cordz_mean_interval(int32_t mean_interval);
 
-// Enable cordz unless any of the following applies:
-// - no thread local support
-// - MSVC build
-// - Android build
-// - Apple build
-// - DLL build
-// Hashtablez is turned off completely in opensource builds.
-// MSVC's static atomics are dynamically initialized in debug mode, which breaks
-// sampling.
-#if defined(ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER)  && \
-    !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL) && \
-    !defined(__ANDROID__) && !defined(__APPLE__)
+// Cordz is only enabled on Linux with thread_local support.
+#if defined(ABSL_INTERNAL_CORDZ_ENABLED)
+#error ABSL_INTERNAL_CORDZ_ENABLED cannot be set directly
+#elif defined(__linux__) && defined(ABSL_HAVE_THREAD_LOCAL)
 #define ABSL_INTERNAL_CORDZ_ENABLED 1
 #endif
 
@@ -82,4 +74,4 @@ inline void cordz_set_next_sample_for_testing(int64_t) {}
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-#endif  // ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#endif  // ABSL_STRINGS_INTERNAL_CORDZ_FUNCTIONS_H_