Optimize binary size and speed: add separate overloads for const char*

for function templates forwarding a parameter of any type `Src` which
`SupportsToStringView<Src>`, with `ABSL_ATTRIBUTE_ALWAYS_INLINE`.

Otherwise string literals instantiate the template with `const char (&)[length]`
separately for each distinct `length`, and if these instantiations are not
inlined, they compute `strlen()` at runtime.

PiperOrigin-RevId: 679111258

riegeli/base/chain_base.h

@@ -190,6 +190,8 @@ class Chain : public WithCompare<Chain> {
 
   // Converts from a string-like type.
   explicit Chain(absl::string_view src);
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  explicit Chain(const char* src) : Chain(absl::string_view(src)) {}
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<
@@ -221,6 +223,10 @@ class Chain : public WithCompare<Chain> {
   // constructing a temporary `Chain` and moving from it.
   ABSL_ATTRIBUTE_REINITIALIZES void Reset();
   ABSL_ATTRIBUTE_REINITIALIZES void Reset(absl::string_view src);
+  ABSL_ATTRIBUTE_REINITIALIZES ABSL_ATTRIBUTE_ALWAYS_INLINE void Reset(
+      const char* src) {
+    Reset(absl::string_view(src));
+  }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<
@@ -316,6 +322,10 @@ class Chain : public WithCompare<Chain> {
 
   // Appends/prepends a string-like type.
   void Append(absl::string_view src, Options options = Options());
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  void Append(const char* src, Options options = Options()) {
+    Append(absl::string_view(src), options);
+  }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<
@@ -338,6 +348,10 @@ class Chain : public WithCompare<Chain> {
             std::enable_if_t<SupportsExternalRefWhole<Src>::value, int> = 0>
   void Append(Src&& src, Options options);
   void Prepend(absl::string_view src, Options options = Options());
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  void Prepend(const char* src, Options options = Options()) {
+    Prepend(absl::string_view(src), options);
+  }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<

riegeli/bytes/backward_writer.h

@@ -161,6 +161,8 @@ class BackwardWriter : public Object {
   bool Write(char8_t src) { return Write(static_cast<char>(src)); }
 #endif
   bool Write(absl::string_view src);
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  bool Write(const char* src) { return Write(absl::string_view(src)); }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<

riegeli/bytes/writer.h

@@ -93,6 +93,9 @@ inline Position StringifiedSize(ABSL_ATTRIBUTE_UNUSED char src) { return 1; }
 inline Position StringifiedSize(ABSL_ATTRIBUTE_UNUSED char8_t src) { return 1; }
 #endif
 inline Position StringifiedSize(absl::string_view src) { return src.size(); }
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline Position StringifiedSize(const char* src) {
+  return absl::string_view(src).size();
+}
 template <typename Src,
           std::enable_if_t<SupportsToStringView<Src>::value, int> = 0>
 inline Position StringifiedSize(Src&& src) {
@@ -276,6 +279,8 @@ class Writer : public Object {
   bool Write(char8_t src) { return Write(static_cast<char>(src)); }
 #endif
   bool Write(absl::string_view src);
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  bool Write(const char* src) { return Write(absl::string_view(src)); }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<

riegeli/chunk_encoding/chunk_encoder.h

@@ -22,6 +22,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/attributes.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
@@ -59,6 +60,9 @@ class ChunkEncoder : public Object {
   virtual bool AddRecord(const google::protobuf::MessageLite& record,
                          SerializeOptions serialize_options);
   virtual bool AddRecord(absl::string_view record) = 0;
+  ABSL_ATTRIBUTE_ALWAYS_INLINE bool AddRecord(const char* record) {
+    return AddRecord(absl::string_view(record));
+  }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<

riegeli/digests/digester_handle.h

@@ -169,6 +169,8 @@ class
   bool Write(char8_t src) { return Write(static_cast<char>(src)); }
 #endif
   bool Write(absl::string_view src) { return methods()->write(target(), src); }
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  bool Write(const char* src) { return Write(absl::string_view(src)); }
   template <typename Src,
             std::enable_if_t<SupportsToStringView<Src>::value, int> = 0>
   bool Write(Src&& src) {

riegeli/records/record_writer.h

@@ -473,6 +473,9 @@ class RecordWriterBase : public Object {
   bool WriteRecord(const google::protobuf::MessageLite& record,
                    SerializeOptions serialize_options = SerializeOptions());
   bool WriteRecord(absl::string_view record);
+  ABSL_ATTRIBUTE_ALWAYS_INLINE bool WriteRecord(const char* record) {
+    return WriteRecord(absl::string_view(record));
+  }
   template <typename Src,
             std::enable_if_t<
                 absl::conjunction<