1 files changed, 58 insertions, 16 deletions

diff --git a/absl/strings/cord.cc b/absl/strings/cord.cc
index 63a82133..0015bb9f 100644
--- a/absl/strings/cord.cc
+++ b/absl/strings/cord.cc
@@ -267,6 +267,7 @@ static CordRep* NewSubstring(CordRep* child, size_t offset, size_t length) {
     return nullptr;
   } else {
     CordRepSubstring* rep = new CordRepSubstring();
+    assert(child->IsExternal() || child->IsFlat());
     assert((offset + length) <= child->length);
     rep->length = length;
     rep->tag = cord_internal::SUBSTRING;
@@ -343,7 +344,9 @@ inline void Cord::InlineRep::remove_prefix(size_t n) {
 // Returns `rep` converted into a CordRepBtree.
 // Directly returns `rep` if `rep` is already a CordRepBtree.
 static CordRepBtree* ForceBtree(CordRep* rep) {
-  return rep->IsBtree() ? rep->btree() : CordRepBtree::Create(rep);
+  return rep->IsBtree()
+             ? rep->btree()
+             : CordRepBtree::Create(cord_internal::RemoveCrcNode(rep));
 }
 
 void Cord::InlineRep::AppendTreeToInlined(CordRep* tree,
@@ -366,13 +369,14 @@ void Cord::InlineRep::AppendTreeToTree(CordRep* tree, MethodIdentifier method) {
   if (btree_enabled()) {
     tree = CordRepBtree::Append(ForceBtree(data_.as_tree()), tree);
   } else {
-    tree = Concat(data_.as_tree(), tree);
+    tree = Concat(cord_internal::RemoveCrcNode(data_.as_tree()), tree);
   }
   SetTree(tree, scope);
 }
 
 void Cord::InlineRep::AppendTree(CordRep* tree, MethodIdentifier method) {
   if (tree == nullptr) return;
+  assert(!tree->IsCrc());
   if (data_.is_tree()) {
     AppendTreeToTree(tree, method);
   } else {
@@ -401,13 +405,14 @@ void Cord::InlineRep::PrependTreeToTree(CordRep* tree,
   if (btree_enabled()) {
     tree = CordRepBtree::Prepend(ForceBtree(data_.as_tree()), tree);
   } else {
-    tree = Concat(tree, data_.as_tree());
+    tree = Concat(tree, cord_internal::RemoveCrcNode(data_.as_tree()));
   }
   SetTree(tree, scope);
 }
 
 void Cord::InlineRep::PrependTree(CordRep* tree, MethodIdentifier method) {
   assert(tree != nullptr);
+  assert(!tree->IsCrc());
   if (data_.is_tree()) {
     PrependTreeToTree(tree, method);
   } else {
@@ -421,7 +426,7 @@ void Cord::InlineRep::PrependTree(CordRep* tree, MethodIdentifier method) {
 // written to region and the actual size increase will be written to size.
 static inline bool PrepareAppendRegion(CordRep* root, char** region,
                                        size_t* size, size_t max_length) {
-  if (root->IsBtree() && root->refcount.IsMutable()) {
+  if (root->IsBtree() && root->refcount.IsOne()) {
     Span<char> span = root->btree()->GetAppendBuffer(max_length);
     if (!span.empty()) {
       *region = span.data();
@@ -432,11 +437,11 @@ static inline bool PrepareAppendRegion(CordRep* root, char** region,
 
   // Search down the right-hand path for a non-full FLAT node.
   CordRep* dst = root;
-  while (dst->IsConcat() && dst->refcount.IsMutable()) {
+  while (dst->IsConcat() && dst->refcount.IsOne()) {
     dst = dst->concat()->right;
   }
 
-  if (!dst->IsFlat() || !dst->refcount.IsMutable()) {
+  if (!dst->IsFlat() || !dst->refcount.IsOne()) {
     *region = nullptr;
     *size = 0;
     return false;
@@ -481,8 +486,9 @@ void Cord::InlineRep::GetAppendRegion(char** region, size_t* size,
   }
 
   size_t extra = has_length ? length : (std::max)(sz, kMinFlatLength);
-  CordRep* rep = root ? root : MakeFlatWithExtraCapacity(extra);
   CordzUpdateScope scope(root ? data_.cordz_info() : nullptr, method);
+  CordRep* rep = root ? cord_internal::RemoveCrcNode(root)
+                      : MakeFlatWithExtraCapacity(extra);
   if (PrepareAppendRegion(rep, region, size, length)) {
     CommitTree(root, rep, scope, method);
     return;
@@ -651,7 +657,7 @@ Cord& Cord::operator=(absl::string_view src) {
   if (tree != nullptr) {
     CordzUpdateScope scope(contents_.cordz_info(), method);
     if (tree->IsFlat() && tree->flat()->Capacity() >= length &&
-        tree->refcount.IsMutable()) {
+        tree->refcount.IsOne()) {
       // Copy in place if the existing FLAT node is reusable.
       memmove(tree->flat()->Data(), data, length);
       tree->length = length;
@@ -677,6 +683,7 @@ void Cord::InlineRep::AppendArray(absl::string_view src,
   const CordRep* const root = rep;
   CordzUpdateScope scope(root ? cordz_info() : nullptr, method);
   if (root != nullptr) {
+    rep = cord_internal::RemoveCrcNode(rep);
     char* region;
     if (PrepareAppendRegion(rep, &region, &appended, src.size())) {
       memcpy(region, src.data(), appended);
@@ -748,7 +755,8 @@ inline void Cord::AppendImpl(C&& src) {
     // Since destination is empty, we can avoid allocating a node,
     if (src.contents_.is_tree()) {
       // by taking the tree directly
-      CordRep* rep = std::forward<C>(src).TakeRep();
+      CordRep* rep =
+          cord_internal::RemoveCrcNode(std::forward<C>(src).TakeRep());
       contents_.EmplaceTree(rep, method);
     } else {
       // or copying over inline data
@@ -784,7 +792,7 @@ inline void Cord::AppendImpl(C&& src) {
   }
 
   // Guaranteed to be a tree (kMaxBytesToCopy > kInlinedSize)
-  CordRep* rep = std::forward<C>(src).TakeRep();
+  CordRep* rep = cord_internal::RemoveCrcNode(std::forward<C>(src).TakeRep());
   contents_.AppendTree(rep, CordzUpdateTracker::kAppendCord);
 }
 
@@ -812,7 +820,8 @@ void Cord::Prepend(const Cord& src) {
   CordRep* src_tree = src.contents_.tree();
   if (src_tree != nullptr) {
     CordRep::Ref(src_tree);
-    contents_.PrependTree(src_tree, CordzUpdateTracker::kPrependCord);
+    contents_.PrependTree(cord_internal::RemoveCrcNode(src_tree),
+                          CordzUpdateTracker::kPrependCord);
     return;
   }
 
@@ -856,6 +865,7 @@ static CordRep* RemovePrefixFrom(CordRep* node, size_t n) {
   if (n == 0) return CordRep::Ref(node);
   absl::InlinedVector<CordRep*, kInlinedVectorSize> rhs_stack;
 
+  assert(!node->IsCrc());
   while (node->IsConcat()) {
     assert(n <= node->length);
     if (n < node->concat()->left->length) {
@@ -896,7 +906,8 @@ static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
   if (n >= node->length) return nullptr;
   if (n == 0) return CordRep::Ref(node);
   absl::InlinedVector<CordRep*, kInlinedVectorSize> lhs_stack;
-  bool inplace_ok = node->refcount.IsMutable();
+  bool inplace_ok = node->refcount.IsOne();
+  assert(!node->IsCrc());
 
   while (node->IsConcat()) {
     assert(n <= node->length);
@@ -909,7 +920,7 @@ static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
       n -= node->concat()->right->length;
       node = node->concat()->left;
     }
-    inplace_ok = inplace_ok && node->refcount.IsMutable();
+    inplace_ok = inplace_ok && node->refcount.IsOne();
   }
   assert(n <= node->length);
 
@@ -946,6 +957,7 @@ void Cord::RemovePrefix(size_t n) {
   } else {
     auto constexpr method = CordzUpdateTracker::kRemovePrefix;
     CordzUpdateScope scope(contents_.cordz_info(), method);
+    tree = cord_internal::RemoveCrcNode(tree);
     if (tree->IsBtree()) {
       CordRep* old = tree;
       tree = tree->btree()->SubTree(n, tree->length - n);
@@ -969,6 +981,7 @@ void Cord::RemoveSuffix(size_t n) {
   } else {
     auto constexpr method = CordzUpdateTracker::kRemoveSuffix;
     CordzUpdateScope scope(contents_.cordz_info(), method);
+    tree = cord_internal::RemoveCrcNode(tree);
     if (tree->IsBtree()) {
       tree = CordRepBtree::RemoveSuffix(tree->btree(), n);
     } else {
@@ -992,6 +1005,7 @@ struct SubRange {
 static CordRep* NewSubRange(CordRep* node, size_t pos, size_t n) {
   absl::InlinedVector<CordRep*, kInlinedVectorSize> results;
   absl::InlinedVector<SubRange, kInlinedVectorSize> todo;
+  assert(!node->IsCrc());
   todo.push_back(SubRange(node, pos, n));
   do {
     const SubRange& sr = todo.back();
@@ -1062,6 +1076,7 @@ Cord Cord::Subcord(size_t pos, size_t new_size) const {
     return sub_cord;
   }
 
+  tree = cord_internal::SkipCrcNode(tree);
   if (tree->IsBtree()) {
     tree = tree->btree()->SubTree(pos, new_size);
   } else {
@@ -1082,6 +1097,7 @@ class CordForest {
 
   void Build(CordRep* cord_root) {
     std::vector<CordRep*> pending = {cord_root};
+    assert(cord_root->IsConcat());
 
     while (!pending.empty()) {
       CordRep* node = pending.back();
@@ -1258,7 +1274,7 @@ inline absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
     return absl::string_view(data_.as_chars(), data_.inline_size());
   }
 
-  CordRep* node = tree();
+  CordRep* node = cord_internal::SkipCrcNode(tree());
   if (node->IsFlat()) {
     return absl::string_view(node->flat()->Data(), node->length);
   }
@@ -1300,6 +1316,28 @@ inline absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
   return absl::string_view(node->external()->base + offset, length);
 }
 
+void Cord::SetExpectedChecksum(uint32_t crc) {
+  auto constexpr method = CordzUpdateTracker::kSetExpectedChecksum;
+  if (empty()) return;
+
+  if (!contents_.is_tree()) {
+    CordRep* rep = contents_.MakeFlatWithExtraCapacity(0);
+    rep = CordRepCrc::New(rep, crc);
+    contents_.EmplaceTree(rep, method);
+  } else {
+    const CordzUpdateScope scope(contents_.data_.cordz_info(), method);
+    CordRep* rep = CordRepCrc::New(contents_.data_.as_tree(), crc);
+    contents_.SetTree(rep, scope);
+  }
+}
+
+absl::optional<uint32_t> Cord::ExpectedChecksum() const {
+  if (!contents_.is_tree() || !contents_.tree()->IsCrc()) {
+    return absl::nullopt;
+  }
+  return contents_.tree()->crc()->crc;
+}
+
 inline int Cord::CompareSlowPath(absl::string_view rhs, size_t compared_size,
                                  size_t size_to_compare) const {
   auto advance = [](Cord::ChunkIterator* it, absl::string_view* chunk) {
@@ -1720,6 +1758,7 @@ char Cord::operator[](size_t i) const {
   if (rep == nullptr) {
     return contents_.data()[i];
   }
+  rep = cord_internal::SkipCrcNode(rep);
   while (true) {
     assert(rep != nullptr);
     assert(offset < rep->length);
@@ -1780,6 +1819,7 @@ absl::string_view Cord::FlattenSlowPath() {
 
 /* static */ bool Cord::GetFlatAux(CordRep* rep, absl::string_view* fragment) {
   assert(rep != nullptr);
+  rep = cord_internal::SkipCrcNode(rep);
   if (rep->IsFlat()) {
     *fragment = absl::string_view(rep->flat()->Data(), rep->length);
     return true;
@@ -1809,6 +1849,9 @@ absl::string_view Cord::FlattenSlowPath() {
 /* static */ void Cord::ForEachChunkAux(
     absl::cord_internal::CordRep* rep,
     absl::FunctionRef<void(absl::string_view)> callback) {
+  assert(rep != nullptr);
+  rep = cord_internal::SkipCrcNode(rep);
+
   if (rep->IsBtree()) {
     ChunkIterator it(rep), end;
     while (it != end) {
@@ -1818,12 +1861,11 @@ absl::string_view Cord::FlattenSlowPath() {
     return;
   }
 
-  assert(rep != nullptr);
   int stack_pos = 0;
   constexpr int stack_max = 128;
   // Stack of right branches for tree traversal
   absl::cord_internal::CordRep* stack[stack_max];
-  absl::cord_internal::CordRep* current_node = rep;
+  absl::cord_internal::CordRep* current_node = cord_internal::SkipCrcNode(rep);
   while (true) {
     if (current_node->IsConcat()) {
       if (stack_pos == stack_max) {