diff --git a/src/google/protobuf/BUILD.bazel b/src/google/protobuf/BUILD.bazel
index a85059c17c..cce73a523e 100644
--- a/src/google/protobuf/BUILD.bazel
+++ b/src/google/protobuf/BUILD.bazel
@@ -646,7 +646,6 @@ cc_library(
         ":port",
         "@abseil-cpp//absl/base:config",
         "@abseil-cpp//absl/log:absl_check",
-        "@abseil-cpp//absl/strings:cord",
         "@abseil-cpp//absl/strings:string_view",
     ],
 )
diff --git a/src/google/protobuf/arenastring.h b/src/google/protobuf/arenastring.h
index b9a2dc5afd..e9dbc4bfab 100644
--- a/src/google/protobuf/arenastring.h
+++ b/src/google/protobuf/arenastring.h
@@ -15,7 +15,6 @@
 #include <utility>
 
 #include "absl/log/absl_check.h"
-#include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/arena.h"
 #include "google/protobuf/explicitly_constructed.h"
@@ -298,7 +297,6 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
 
   void Set(absl::string_view value, Arena* arena);
   void Set(std::string&& value, Arena* arena);
-  void Set(const absl::Cord& value, Arena* arena);
   template <typename... OverloadDisambiguator>
   void Set(const std::string& value, Arena* arena);
   void Set(const char* s, Arena* arena);
@@ -308,7 +306,6 @@ struct PROTOBUF_EXPORT ArenaStringPtr {
   void SetBytes(std::string&& value, Arena* arena);
   template <typename... OverloadDisambiguator>
   void SetBytes(const std::string& value, Arena* arena);
-  void SetBytes(const absl::Cord& value, Arena* arena);
   void SetBytes(const char* s, Arena* arena);
   void SetBytes(const void* p, size_t n, Arena* arena);
 
@@ -468,14 +465,6 @@ inline void ArenaStringPtr::InitAllocated(std::string* str, Arena* arena) {
   }
 }
 
-inline void ArenaStringPtr::Set(const absl::Cord& value, Arena* arena) {
-  if (auto flat = value.TryFlat(); flat.has_value()) {
-    Set(*flat, arena);
-  } else {
-    absl::CopyCordToString(value, MutableNoCopy(arena));
-  }
-}
-
 inline void ArenaStringPtr::Set(const char* s, Arena* arena) {
   ABSL_DCHECK(s != nullptr);
   Set(absl::string_view{s}, arena);
@@ -502,10 +491,6 @@ inline void ArenaStringPtr::SetBytes(std::string&& value, Arena* arena) {
   Set(std::move(value), arena);
 }
 
-inline void ArenaStringPtr::SetBytes(const absl::Cord& value, Arena* arena) {
-  Set(value, arena);
-}
-
 inline void ArenaStringPtr::SetBytes(const char* s, Arena* arena) {
   Set(s, arena);
 }
diff --git a/src/google/protobuf/generated_message_reflection.cc b/src/google/protobuf/generated_message_reflection.cc
index bf85c03dd0..44ea3432df 100644
--- a/src/google/protobuf/generated_message_reflection.cc
+++ b/src/google/protobuf/generated_message_reflection.cc
@@ -315,16 +315,6 @@ using internal::GetConstPointerAtOffset;
 using internal::GetConstRefAtOffset;
 using internal::GetPointerAtOffset;
 
-template <typename String>
-static void Assign(std::string& str, String&& value) {
-  using RawString = std::decay_t<String>;
-  if constexpr (std::is_same_v<RawString, absl::Cord>) {
-    absl::CopyCordToString(value, &str);
-  } else {
-    str.assign(std::forward<String>(value));
-  }
-}
-
 void ReportReflectionUsageError(const Descriptor* descriptor,
                                 const FieldDescriptor* field,
                                 const char* method, const char* description) {
@@ -2195,18 +2185,13 @@ absl::string_view Reflection::GetStringView(const Message& message,
 }
 
 
-template <typename String>
-void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
-                               String&& value) const {
+void Reflection::SetString(Message* message, const FieldDescriptor* field,
+                           std::string value) const {
+  USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
   Arena* arena = message->GetArena();
   if (field->is_extension()) {
-    Assign(*MutableExtensionSet(message)->MutableString(
-               arena, field->number(),
-               field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
-                                                 : FieldDescriptor::TYPE_BYTES,
-               field),
-           std::forward<String>(value));
-    return;
+    return MutableExtensionSet(message)->Set<std::string>(
+        arena, field->number(), field->type(), std::move(value), field);
   } else {
     switch (field->cpp_string_type()) {
       case FieldDescriptor::CppStringType::kCord:
@@ -2216,17 +2201,15 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
             *MutableField<absl::Cord*>(message, field) =
                 Arena::Create<absl::Cord>(arena);
           }
-          **MutableField<absl::Cord*>(message, field) =
-              std::forward<String>(value);
+          *(*MutableField<absl::Cord*>(message, field)) = value;
           break;
         }
-        *MutableField<absl::Cord>(message, field) = std::forward<String>(value);
+        *MutableField<absl::Cord>(message, field) = value;
         break;
       case FieldDescriptor::CppStringType::kView:
       case FieldDescriptor::CppStringType::kString: {
         if (IsInlined(field)) {
-          MutableField<InlinedStringField>(message, field)
-              ->Set(std::forward<String>(value), arena);
+          MutableField<InlinedStringField>(message, field)->Set(value, arena);
           break;
         } else if (IsMicroString(field)) {
           if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
@@ -2234,7 +2217,7 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
             MutableField<MicroString>(message, field)->InitDefault();
           }
           MutableField<MicroString>(message, field)
-              ->Set(std::forward<String>(value), arena);
+              ->Set(std::move(value), arena);
           break;
         }
 
@@ -2247,29 +2230,59 @@ void Reflection::SetStringImpl(Message* message, const FieldDescriptor* field,
           MutableField<ArenaStringPtr>(message, field)->InitDefault();
         }
         MutableField<ArenaStringPtr>(message, field)
-            ->Set(std::forward<String>(value), arena);
+            ->Set(std::move(value), arena);
         break;
       }
     }
   }
 }
 
-void Reflection::SetString(Message* message, const FieldDescriptor* field,
-                           std::string value) const {
-  USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
-  SetStringImpl(message, field, std::move(value));
-}
-
-void Reflection::SetStringView(Message* message, const FieldDescriptor* field,
-                               absl::string_view value) const {
-  USAGE_MUTABLE_CHECK_ALL(SetStringView, SINGULAR, STRING);
-  SetStringImpl(message, field, value);
-}
-
 void Reflection::SetString(Message* message, const FieldDescriptor* field,
                            const absl::Cord& value) const {
   USAGE_MUTABLE_CHECK_ALL(SetString, SINGULAR, STRING);
-  SetStringImpl(message, field, value);
+  Arena* arena = message->GetArena();
+  if (field->is_extension()) {
+    return absl::CopyCordToString(
+        value, MutableExtensionSet(message)->MutableString(
+                   arena, field->number(), field->type(), field));
+  } else {
+    switch (field->cpp_string_type()) {
+      case FieldDescriptor::CppStringType::kCord:
+        if (schema_.InRealOneof(field)) {
+          if (!HasOneofField(*message, field)) {
+            ClearOneof(message, field->containing_oneof());
+            *MutableField<absl::Cord*>(message, field) =
+                Arena::Create<absl::Cord>(arena);
+          }
+          *(*MutableField<absl::Cord*>(message, field)) = value;
+        } else {
+          *MutableField<absl::Cord>(message, field) = value;
+        }
+        break;
+      case FieldDescriptor::CppStringType::kView:
+      case FieldDescriptor::CppStringType::kString: {
+        if (IsInlined(field)) {
+          auto* str = MutableField<InlinedStringField>(message, field);
+          str->Set(std::string(value), arena);
+        } else if (IsMicroString(field)) {
+          if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
+            ClearOneof(message, field->containing_oneof());
+            MutableField<MicroString>(message, field)->InitDefault();
+          }
+          auto* str = MutableField<MicroString>(message, field);
+          str->Set(std::string(value), arena);
+        } else {
+          if (schema_.InRealOneof(field) && !HasOneofField(*message, field)) {
+            ClearOneof(message, field->containing_oneof());
+            MutableField<ArenaStringPtr>(message, field)->InitDefault();
+          }
+          auto* str = MutableField<ArenaStringPtr>(message, field);
+          str->Set(std::string(value), arena);
+        }
+        break;
+      }
+    }
+  }
 }
 
 std::string Reflection::GetRepeatedString(const Message& message,
@@ -2343,80 +2356,48 @@ absl::string_view Reflection::GetRepeatedStringView(
 }
 
 
-template <typename String>
-void Reflection::SetRepeatedStringImpl(Message* message,
-                                       const FieldDescriptor* field, int index,
-                                       String&& value) const {
-  if (field->is_extension()) {
-    Assign(*MutableExtensionSet(message)->MutableRepeatedString(field->number(),
-                                                                index),
-           std::forward<String>(value));
-  } else {
-    switch (field->cpp_string_type()) {
-      case FieldDescriptor::CppStringType::kCord:
-        SetRepeatedField<absl::Cord>(message, field, index,
-                                     absl::Cord(std::forward<String>(value)));
-        break;
-      case FieldDescriptor::CppStringType::kView:
-      case FieldDescriptor::CppStringType::kString:
-        Assign(*MutableRepeatedField<std::string>(message, field, index),
-               std::forward<String>(value));
-        break;
-    }
-  }
-}
-
 void Reflection::SetRepeatedString(Message* message,
                                    const FieldDescriptor* field, int index,
                                    std::string value) const {
   USAGE_MUTABLE_CHECK_ALL(SetRepeatedString, REPEATED, STRING);
-  SetRepeatedStringImpl(message, field, index, std::move(value));
-}
-
-void Reflection::SetRepeatedStringView(Message* message,
-                                       const FieldDescriptor* field, int index,
-                                       absl::string_view value) const {
-  USAGE_MUTABLE_CHECK_ALL(SetRepeatedStringView, REPEATED, STRING);
-  SetRepeatedStringImpl(message, field, index, value);
-}
-
-
-template <typename String>
-void Reflection::AddStringImpl(Message* message, const FieldDescriptor* field,
-                               String&& value) const {
-  Arena* arena = message->GetArena();
   if (field->is_extension()) {
-    Assign(*MutableExtensionSet(message)->AddString(
-               arena, field->number(),
-               field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
-                                                 : FieldDescriptor::TYPE_BYTES,
-               field),
-           std::forward<String>(value));
+    MutableExtensionSet(message)->SetRepeated<std::string>(
+        field->number(), index, std::move(value));
   } else {
     switch (field->cpp_string_type()) {
       case FieldDescriptor::CppStringType::kCord:
-        AddField<absl::Cord>(message, field,
-                             absl::Cord(std::forward<String>(value)));
+        SetRepeatedField<absl::Cord>(message, field, index, absl::Cord(value));
         break;
       case FieldDescriptor::CppStringType::kView:
       case FieldDescriptor::CppStringType::kString:
-        Assign(*AddField<std::string>(message, field),
-               std::forward<String>(value));
+        MutableRepeatedField<std::string>(message, field, index)
+            ->assign(std::move(value));
         break;
     }
   }
 }
 
+
 void Reflection::AddString(Message* message, const FieldDescriptor* field,
                            std::string value) const {
   USAGE_MUTABLE_CHECK_ALL(AddString, REPEATED, STRING);
-  AddStringImpl(message, field, std::move(value));
-}
-
-void Reflection::AddStringView(Message* message, const FieldDescriptor* field,
-                               absl::string_view value) const {
-  USAGE_MUTABLE_CHECK_ALL(AddStringView, REPEATED, STRING);
-  AddStringImpl(message, field, value);
+  if (field->is_extension()) {
+    MutableExtensionSet(message)->Add<std::string>(
+        message->GetArena(), field->number(),
+        field->requires_utf8_validation() ? FieldDescriptor::TYPE_STRING
+                                          : FieldDescriptor::TYPE_BYTES,
+        field) = std::move(value);
+  } else {
+    switch (field->cpp_string_type()) {
+      case FieldDescriptor::CppStringType::kCord:
+        AddField<absl::Cord>(message, field, absl::Cord(value));
+        break;
+      case FieldDescriptor::CppStringType::kView:
+      case FieldDescriptor::CppStringType::kString:
+        AddField<std::string>(message, field)->assign(std::move(value));
+        break;
+    }
+  }
 }
 
 
diff --git a/src/google/protobuf/inlined_string_field.h b/src/google/protobuf/inlined_string_field.h
index b07f0b4954..1577afb765 100644
--- a/src/google/protobuf/inlined_string_field.h
+++ b/src/google/protobuf/inlined_string_field.h
@@ -14,7 +14,6 @@
 #include <utility>
 
 #include "absl/log/absl_check.h"
-#include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/arenastring.h"
 #include "google/protobuf/explicitly_constructed.h"
@@ -101,7 +100,6 @@ class PROTOBUF_EXPORT InlinedStringField {
 
   // Lvalue Set.
   void Set(absl::string_view value, Arena* arena);
-  void Set(const absl::Cord& value, Arena* arena);
 
   // Rvalue Set. If this field is donated, this method might undonate this
   // field.
@@ -321,14 +319,6 @@ inline void InlinedStringField::Set(absl::string_view value, Arena* arena) {
   SetNoArena(value);
 }
 
-inline void InlinedStringField::Set(const absl::Cord& value, Arena* arena) {
-  if (auto flat = value.TryFlat(); flat.has_value()) {
-    Set(*flat, arena);
-  } else {
-    Set(std::string(value), arena);
-  }
-}
-
 inline void InlinedStringField::Set(const char* str, Arena* arena) {
   Set(absl::string_view(str), arena);
 }
diff --git a/src/google/protobuf/message.h b/src/google/protobuf/message.h
index e30109b935..f48082cc8d 100644
--- a/src/google/protobuf/message.h
+++ b/src/google/protobuf/message.h
@@ -1493,27 +1493,6 @@ class PROTOBUF_EXPORT Reflection final {
                                              const Reflection* reflection,
                                              const char* ptr,
                                              internal::ParseContext* ctx);
-  void SetStringView(Message* message, const FieldDescriptor* field,
-                     absl::string_view value) const;
-  void SetRepeatedStringView(Message* message, const FieldDescriptor* field,
-                             int index, absl::string_view value) const;
-  void AddStringView(Message* message, const FieldDescriptor* field,
-                     absl::string_view value) const;
-
-  // Supports const absl::Cord&, std::string&& and absl::string_view.
-  template <typename String>
-  void SetStringImpl(Message* message, const FieldDescriptor* field,
-                     String&& value) const;
-
-  // Supports const absl::Cord&, std::string&& and absl::string_view.
-  template <typename String>
-  void SetRepeatedStringImpl(Message* message, const FieldDescriptor* field,
-                             int index, String&& value) const;
-
-  // Supports const absl::Cord&, std::string&& and absl::string_view.
-  template <typename String>
-  void AddStringImpl(Message* message, const FieldDescriptor* field,
-                     String&& value) const;
 };
 
 extern template void Reflection::SwapFieldsImpl<true>(
diff --git a/src/google/protobuf/micro_string.h b/src/google/protobuf/micro_string.h
index e38892ad22..178c78ce48 100644
--- a/src/google/protobuf/micro_string.h
+++ b/src/google/protobuf/micro_string.h
@@ -14,7 +14,6 @@
 
 #include "absl/base/config.h"
 #include "absl/log/absl_check.h"
-#include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/arena.h"
 
@@ -206,14 +205,6 @@ class PROTOBUF_EXPORT MicroString {
   void Set(absl::string_view data, Arena* arena) {
     SetMaybeConstant(*this, data, arena);
   }
-
-  void Set(const absl::Cord& value, Arena* arena) {
-    SetInChunks(value.size(), arena, [&value](auto append) {
-      for (absl::string_view chunk : value.Chunks()) {
-        append(chunk);
-      }
-    });
-  }
   void Set(absl::string_view data, Arena* arena, size_t inline_capacity) {
     SetImpl(data, arena, inline_capacity);
   }