grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/transport/parsed_metadata.cc

@@ -31,5 +31,7 @@ void DestroySliceValue(const Buffer& value) {
   grpc_slice_unref_internal(value.slice);
 }
 
+void DestroyTrivialMemento(const Buffer&) {}
+
 }  // namespace metadata_detail
 }  // namespace grpc_core

data/src/core/lib/transport/parsed_metadata.h

@@ -26,10 +26,12 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata.h"
 
 namespace grpc_core {
 
+using MetadataParseErrorFn =
+    absl::FunctionRef<void(absl::string_view error, const Slice& value)>;
+
 namespace metadata_detail {
 
 // Helper to determine whether a traits metadata is inlinable inside a memento,
@@ -38,15 +40,14 @@ template <typename Which>
 struct HasSimpleMemento {
   static constexpr bool value =
       std::is_trivial<typename Which::MementoType>::value &&
-      sizeof(typename Which::MementoType) <= sizeof(uint64_t);
+      sizeof(typename Which::MementoType) <= sizeof(grpc_slice);
 };
 
 // Storage type for a single metadata entry.
 union Buffer {
-  uint64_t trivial;
+  char trivial[sizeof(grpc_slice)];
   void* pointer;
   grpc_slice slice;
-  grpc_mdelem mdelem;
 };
 
 // Given a key and a value, concatenate together to make a debug string.
@@ -71,7 +72,9 @@ GPR_ATTRIBUTE_NOINLINE std::string MakeDebugStringPipeline(
 // Extract a trivial field value from a Buffer - for MakeDebugStringPipeline.
 template <typename Field>
 Field FieldFromTrivial(const Buffer& value) {
-  return static_cast<Field>(value.trivial);
+  Field x;
+  memcpy(&x, value.trivial, sizeof(x));
+  return x;
 }
 
 // Extract a pointer field value from a Buffer - for MakeDebugStringPipeline.
@@ -86,6 +89,9 @@ Slice SliceFromBuffer(const Buffer& buffer);
 // Unref the grpc_slice part of a Buffer (assumes it is in fact a grpc_slice).
 void DestroySliceValue(const Buffer& value);
 
+// Destroy a trivial memento (empty function).
+void DestroyTrivialMemento(const Buffer& value);
+
 }  // namespace metadata_detail
 
 // A parsed metadata value.
@@ -107,7 +113,7 @@ class ParsedMetadata {
       uint32_t transport_size)
       : vtable_(ParsedMetadata::template TrivialTraitVTable<Which>()),
         transport_size_(transport_size) {
-    value_.trivial = static_cast<uint64_t>(value);
+    memcpy(value_.trivial, &value, sizeof(value));
   }
   template <typename Which>
   ParsedMetadata(
@@ -129,13 +135,12 @@ class ParsedMetadata {
         transport_size_(transport_size) {
     value_.slice = value.TakeCSlice();
   }
-  // Takes ownership of elem
-  explicit ParsedMetadata(grpc_mdelem elem)
-      : vtable_(grpc_is_binary_header_internal(GRPC_MDKEY(elem))
-                    ? MdelemVtable<true>()
-                    : MdelemVtable<false>()),
-        transport_size_(GRPC_MDELEM_LENGTH(elem)) {
-    value_.mdelem = elem;
+  // Construct metadata from a string key, slice value pair.
+  ParsedMetadata(Slice key, Slice value)
+      : vtable_(ParsedMetadata::KeyValueVTable(key.as_string_view())),
+        transport_size_(key.size() + value.size() + 32) {
+    value_.pointer =
+        new std::pair<Slice, Slice>(std::move(key), std::move(value));
   }
   ParsedMetadata() : vtable_(EmptyVTable()), transport_size_(0) {}
   ~ParsedMetadata() { vtable_->destroy(value_); }
@@ -158,9 +163,8 @@ class ParsedMetadata {
   }
 
   // Set this parsed value on a container.
-  GRPC_MUST_USE_RESULT grpc_error_handle
-  SetOnContainer(MetadataContainer* container) const {
-    return vtable_->set(value_, container);
+  void SetOnContainer(MetadataContainer* container) const {
+    vtable_->set(value_, container);
   }
 
   // Is this a binary header or not?
@@ -168,16 +172,18 @@ class ParsedMetadata {
   // HTTP2 defined storage size of this metadatum.
   uint32_t transport_size() const { return transport_size_; }
   // Create a new parsed metadata with the same key but a different value.
-  ParsedMetadata WithNewValue(Slice value) const {
+  ParsedMetadata WithNewValue(Slice value,
+                              MetadataParseErrorFn on_error) const {
     ParsedMetadata result;
     result.vtable_ = vtable_;
     result.value_ = value_;
     result.transport_size_ =
-        TransportSize(vtable_->key_length(value_), value.length());
-    vtable_->with_new_value(&value, &result);
+        TransportSize(vtable_->key(value_).length(), value.length());
+    vtable_->with_new_value(&value, on_error, &result);
     return result;
   }
   std::string DebugString() const { return vtable_->debug_string(value_); }
+  absl::string_view key() const { return vtable_->key(value_); }
 
   // TODO(ctiller): move to transport
   static uint32_t TransportSize(uint32_t key_size, uint32_t value_size) {
@@ -191,29 +197,36 @@ class ParsedMetadata {
   struct VTable {
     const bool is_binary_header;
     void (*const destroy)(const Buffer& value);
-    grpc_error_handle (*const set)(const Buffer& value,
-                                   MetadataContainer* container);
+    void (*const set)(const Buffer& value, MetadataContainer* container);
     // result is a bitwise copy of the originating ParsedMetadata.
-    void (*const with_new_value)(Slice* new_value, ParsedMetadata* result);
+    void (*const with_new_value)(Slice* new_value,
+                                 MetadataParseErrorFn on_error,
+                                 ParsedMetadata* result);
     std::string (*const debug_string)(const Buffer& value);
-    // TODO(ctiller): when we delete mdelem, make this a simple integer constant
-    // on the vtable
-    size_t (*const key_length)(const Buffer& value);
+    absl::string_view (*const key)(const Buffer& value);
   };
 
   static const VTable* EmptyVTable();
+  static const VTable* KeyValueVTable(absl::string_view key);
   template <typename Which>
   static const VTable* TrivialTraitVTable();
   template <typename Which>
   static const VTable* NonTrivialTraitVTable();
   template <typename Which>
   static const VTable* SliceTraitVTable();
-  template <bool kIsBinaryHeader>
-  static const VTable* MdelemVtable();
 
-  template <Slice (*ParseMemento)(Slice)>
-  GPR_ATTRIBUTE_NOINLINE void WithNewValueSetSlice(Slice* slice) {
-    value_.slice = ParseMemento(std::move(*slice)).TakeCSlice();
+  template <Slice (*ParseMemento)(Slice, MetadataParseErrorFn)>
+  GPR_ATTRIBUTE_NOINLINE static void WithNewValueSetSlice(
+      Slice* slice, MetadataParseErrorFn on_error, ParsedMetadata* result) {
+    result->value_.slice =
+        ParseMemento(std::move(*slice), on_error).TakeCSlice();
+  }
+
+  template <typename T, T (*ParseMemento)(Slice, MetadataParseErrorFn)>
+  GPR_ATTRIBUTE_NOINLINE static void WithNewValueSetTrivial(
+      Slice* slice, MetadataParseErrorFn on_error, ParsedMetadata* result) {
+    T memento = ParseMemento(std::move(*slice), on_error);
+    memcpy(result->value_.trivial, &memento, sizeof(memento));
   }
 
   const VTable* vtable_;
@@ -229,15 +242,15 @@ ParsedMetadata<MetadataContainer>::EmptyVTable() {
   static const VTable vtable = {
       false,
       // destroy
-      [](const Buffer&) {},
+      metadata_detail::DestroyTrivialMemento,
       // set
-      [](const Buffer&, MetadataContainer*) { return GRPC_ERROR_NONE; },
+      [](const Buffer&, MetadataContainer*) {},
       // with_new_value
-      [](Slice*, ParsedMetadata*) {},
+      [](Slice*, MetadataParseErrorFn, ParsedMetadata*) {},
       // debug_string
       [](const Buffer&) -> std::string { return "empty"; },
-      // key_length
-      [](const Buffer&) -> size_t { return 0; },
+      // key
+      [](const Buffer&) -> absl::string_view { return ""; },
   };
   return &vtable;
 }
@@ -249,18 +262,17 @@ ParsedMetadata<MetadataContainer>::TrivialTraitVTable() {
   static const VTable vtable = {
       absl::EndsWith(Which::key(), "-bin"),
       // destroy
-      [](const Buffer&) {},
+      metadata_detail::DestroyTrivialMemento,
       // set
       [](const Buffer& value, MetadataContainer* map) {
-        map->Set(Which(),
-                 Which::MementoToValue(
-                     static_cast<typename Which::MementoType>(value.trivial)));
-        return GRPC_ERROR_NONE;
+        map->Set(
+            Which(),
+            Which::MementoToValue(
+                metadata_detail::FieldFromTrivial<typename Which::MementoType>(
+                    value)));
       },
       // with_new_value
-      [](Slice* value, ParsedMetadata* result) {
-        result->value_.trivial = Which::ParseMemento(std::move(*value));
-      },
+      WithNewValueSetTrivial<typename Which::MementoType, Which::ParseMemento>,
       // debug_string
       [](const Buffer& value) {
         return metadata_detail::MakeDebugStringPipeline(
@@ -268,8 +280,8 @@ ParsedMetadata<MetadataContainer>::TrivialTraitVTable() {
             metadata_detail::FieldFromTrivial<typename Which::MementoType>,
             Which::DisplayValue);
       },
-      // key_length
-      [](const Buffer&) { return Which::key().size(); },
+      // key
+      [](const Buffer&) { return Which::key(); },
   };
   return &vtable;
 }
@@ -288,12 +300,11 @@ ParsedMetadata<MetadataContainer>::NonTrivialTraitVTable() {
       [](const Buffer& value, MetadataContainer* map) {
         auto* p = static_cast<typename Which::MementoType*>(value.pointer);
         map->Set(Which(), Which::MementoToValue(*p));
-        return GRPC_ERROR_NONE;
       },
       // with_new_value
-      [](Slice* value, ParsedMetadata* result) {
-        result->value_.pointer = new
-            typename Which::MementoType(Which::ParseMemento(std::move(*value)));
+      [](Slice* value, MetadataParseErrorFn on_error, ParsedMetadata* result) {
+        result->value_.pointer = new typename Which::MementoType(
+            Which::ParseMemento(std::move(*value), on_error));
       },
       // debug_string
       [](const Buffer& value) {
@@ -302,8 +313,8 @@ ParsedMetadata<MetadataContainer>::NonTrivialTraitVTable() {
             metadata_detail::FieldFromPointer<typename Which::MementoType>,
             Which::DisplayValue);
       },
-      // key_length
-      [](const Buffer&) { return Which::key().size(); },
+      // key
+      [](const Buffer&) { return Which::key(); },
   };
   return &vtable;
 }
@@ -320,61 +331,53 @@ ParsedMetadata<MetadataContainer>::SliceTraitVTable() {
       [](const Buffer& value, MetadataContainer* map) {
         map->Set(Which(), Which::MementoToValue(
                               metadata_detail::SliceFromBuffer(value)));
-        return GRPC_ERROR_NONE;
       },
       // with_new_value
-      [](Slice* value, ParsedMetadata* result) {
-        result->WithNewValueSetSlice<Which::ParseMemento>(value);
-      },
+      WithNewValueSetSlice<Which::ParseMemento>,
       // debug_string
       [](const Buffer& value) {
         return metadata_detail::MakeDebugStringPipeline(
             Which::key(), value, metadata_detail::SliceFromBuffer,
             Which::DisplayValue);
       },
-      // key_length
-      [](const Buffer&) { return Which::key().size(); },
+      // key
+      [](const Buffer&) { return Which::key(); },
   };
   return &vtable;
 }
 
 template <typename MetadataContainer>
-template <bool kIsBinaryHeader>
 const typename ParsedMetadata<MetadataContainer>::VTable*
-ParsedMetadata<MetadataContainer>::MdelemVtable() {
-  static const VTable vtable = {
-      kIsBinaryHeader,
-      // destroy
-      [](const Buffer& value) { GRPC_MDELEM_UNREF(value.mdelem); },
-      // set
-      [](const Buffer& value, MetadataContainer* map) {
-        auto md = GRPC_MDELEM_REF(value.mdelem);
-        auto err = map->Append(md);
-        // If an error occurs, md is not consumed and we need to.
-        // This is an awful API, but that's why we're replacing it.
-        if (err != GRPC_ERROR_NONE) {
-          GRPC_MDELEM_UNREF(md);
-        }
-        return err;
-      },
-      // with_new_value
-      [](Slice* value_slice, ParsedMetadata* result) {
-        result->value_.mdelem = grpc_mdelem_from_slices(
-            static_cast<const ManagedMemorySlice&>(
-                grpc_slice_ref_internal(GRPC_MDKEY(result->value_.mdelem))),
-            value_slice->TakeCSlice());
-      },
-      // debug_string
-      [](const Buffer& value) {
-        return metadata_detail::MakeDebugString(
-            StringViewFromSlice(GRPC_MDKEY(value.mdelem)),
-            StringViewFromSlice(GRPC_MDVALUE(value.mdelem)));
-      },
-      // key_length
-      [](const Buffer& value) {
-        return GRPC_SLICE_LENGTH(GRPC_MDKEY(value.mdelem));
-      }};
-  return &vtable;
+ParsedMetadata<MetadataContainer>::KeyValueVTable(absl::string_view key) {
+  using KV = std::pair<Slice, Slice>;
+  static const auto destroy = [](const Buffer& value) {
+    delete static_cast<KV*>(value.pointer);
+  };
+  static const auto set = [](const Buffer& value, MetadataContainer* map) {
+    auto* p = static_cast<KV*>(value.pointer);
+    map->AppendUnknown(p->first.as_string_view(), p->second.Ref());
+  };
+  static const auto with_new_value = [](Slice* value, MetadataParseErrorFn,
+                                        ParsedMetadata* result) {
+    auto* p = new KV{
+        static_cast<KV*>(result->value_.pointer)->first.Ref(),
+        std::move(*value),
+    };
+    result->value_.pointer = p;
+  };
+  static const auto debug_string = [](const Buffer& value) {
+    auto* p = static_cast<KV*>(value.pointer);
+    return absl::StrCat(p->first.as_string_view(), ": ",
+                        p->second.as_string_view());
+  };
+  static const auto key_fn = [](const Buffer& value) {
+    return static_cast<KV*>(value.pointer)->first.as_string_view();
+  };
+  static const VTable vtable[2] = {
+      {false, destroy, set, with_new_value, debug_string, key_fn},
+      {true, destroy, set, with_new_value, debug_string, key_fn},
+  };
+  return &vtable[absl::EndsWith(key, "-bin")];
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/timeout_encoding.cc

@@ -23,83 +23,215 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
 
-static int64_t round_up(int64_t x, int64_t divisor) {
-  return (x / divisor + (x % divisor != 0)) * divisor;
+namespace grpc_core {
+
+namespace {
+
+int64_t DivideRoundingUp(int64_t dividend, int64_t divisor) {
+  return (dividend + divisor - 1) / divisor;
 }
 
-/* round an integer up to the next value with three significant figures */
-static int64_t round_up_to_three_sig_figs(int64_t x) {
-  if (x < 1000) return x;
-  if (x < 10000) return round_up(x, 10);
-  if (x < 100000) return round_up(x, 100);
-  if (x < 1000000) return round_up(x, 1000);
-  if (x < 10000000) return round_up(x, 10000);
-  if (x < 100000000) return round_up(x, 100000);
-  if (x < 1000000000) return round_up(x, 1000000);
-  return round_up(x, 10000000);
+constexpr int64_t kSecondsPerMinute = 60;
+constexpr int64_t kMinutesPerHour = 60;
+constexpr int64_t kSecondsPerHour = kSecondsPerMinute * kMinutesPerHour;
+constexpr int64_t kMaxHours = 27000;
+
+bool IsAllSpace(const uint8_t* p, const uint8_t* end) {
+  while (p != end && *p == ' ') p++;
+  return p == end;
 }
 
-/* encode our minimum viable timeout value */
-static void enc_tiny(char* buffer) { memcpy(buffer, "1n", 3); }
+}  // namespace
 
-/* encode our maximum timeout value, about 1157 days */
-static void enc_huge(char* buffer) { memcpy(buffer, "99999999S", 10); }
+Timeout Timeout::FromDuration(grpc_millis duration) {
+  return Timeout::FromMillis(duration);
+}
 
-static void enc_ext(char* buffer, int64_t value, char ext) {
-  int n = int64_ttoa(value, buffer);
-  buffer[n] = ext;
-  buffer[n + 1] = 0;
+double Timeout::RatioVersus(Timeout other) const {
+  double a = AsDuration();
+  double b = other.AsDuration();
+  if (b == 0) {
+    if (a > 0) return 100;
+    if (a < 0) return -100;
+    return 0;
+  }
+  return 100 * (a / b - 1);
 }
 
-static void enc_seconds(char* buffer, int64_t sec) {
-  sec = round_up_to_three_sig_figs(sec);
-  if (sec % 3600 == 0) {
-    enc_ext(buffer, sec / 3600, 'H');
-  } else if (sec % 60 == 0) {
-    enc_ext(buffer, sec / 60, 'M');
-  } else {
-    enc_ext(buffer, sec, 'S');
+grpc_millis Timeout::AsDuration() const {
+  grpc_millis value = value_;
+  switch (unit_) {
+    case Unit::kNanoseconds:
+      return 0;
+    case Unit::kMilliseconds:
+      return value;
+    case Unit::kTenMilliseconds:
+      return value * 10;
+    case Unit::kHundredMilliseconds:
+      return value * 100;
+    case Unit::kSeconds:
+      return value * 1000;
+    case Unit::kTenSeconds:
+      return value * 10000;
+    case Unit::kHundredSeconds:
+      return value * 100000;
+    case Unit::kMinutes:
+      return value * 1000 * kSecondsPerMinute;
+    case Unit::kTenMinutes:
+      return value * 10000 * kSecondsPerMinute;
+    case Unit::kHundredMinutes:
+      return value * 100000 * kSecondsPerMinute;
+    case Unit::kHours:
+      return value * 1000 * kSecondsPerHour;
   }
+  GPR_UNREACHABLE_CODE(return -1);
 }
 
-static void enc_millis(char* buffer, int64_t x) {
-  x = round_up_to_three_sig_figs(x);
-  if (x < GPR_MS_PER_SEC) {
-    enc_ext(buffer, x, 'm');
+Slice Timeout::Encode() const {
+  char buf[10];
+  char* p = buf;
+  uint16_t n = value_;
+  int digits;
+  if (n >= 10000) {
+    digits = 5;
+  } else if (n >= 1000) {
+    digits = 4;
+  } else if (n >= 100) {
+    digits = 3;
+  } else if (n >= 10) {
+    digits = 2;
   } else {
-    if (x % GPR_MS_PER_SEC == 0) {
-      enc_seconds(buffer, x / GPR_MS_PER_SEC);
-    } else {
-      enc_ext(buffer, x, 'm');
+    digits = 1;
+  }
+  switch (digits) {
+    case 5:
+      *p++ = '0' + n / 10000;
+      n %= 10000;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 4:
+      *p++ = '0' + n / 1000;
+      n %= 1000;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 3:
+      *p++ = '0' + n / 100;
+      n %= 100;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 2:
+      *p++ = '0' + n / 10;
+      n %= 10;
+      ABSL_FALLTHROUGH_INTENDED;
+    case 1:
+      *p++ = '0' + n;
+  }
+  switch (unit_) {
+    case Unit::kNanoseconds:
+      *p++ = 'n';
+      break;
+    case Unit::kHundredMilliseconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenMilliseconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kMilliseconds:
+      *p++ = 'm';
+      break;
+    case Unit::kHundredSeconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenSeconds:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kSeconds:
+      *p++ = 'S';
+      break;
+    case Unit::kHundredMinutes:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kTenMinutes:
+      *p++ = '0';
+      ABSL_FALLTHROUGH_INTENDED;
+    case Unit::kMinutes:
+      *p++ = 'M';
+      break;
+    case Unit::kHours:
+      *p++ = 'H';
+      break;
+  }
+  return Slice::FromCopiedBuffer(buf, p - buf);
+}
+
+Timeout Timeout::FromMillis(int64_t millis) {
+  if (millis <= 0) {
+    return Timeout(1, Unit::kNanoseconds);
+  } else if (millis < 1000) {
+    return Timeout(millis, Unit::kMilliseconds);
+  } else if (millis < 10000) {
+    int64_t value = DivideRoundingUp(millis, 10);
+    if (value % 100 != 0) return Timeout(value, Unit::kTenMilliseconds);
+  } else if (millis < 100000) {
+    int64_t value = DivideRoundingUp(millis, 100);
+    if (value % 10 != 0) return Timeout(value, Unit::kHundredMilliseconds);
+  }
+  return Timeout::FromSeconds(DivideRoundingUp(millis, 1000));
+}
+
+Timeout Timeout::FromSeconds(int64_t seconds) {
+  GPR_DEBUG_ASSERT(seconds != 0);
+  if (seconds < 1000) {
+    if (seconds % kSecondsPerMinute != 0) {
+      return Timeout(seconds, Unit::kSeconds);
+    }
+  } else if (seconds < 10000) {
+    int64_t value = DivideRoundingUp(seconds, 10);
+    if ((value * 10) % kSecondsPerMinute != 0) {
+      return Timeout(value, Unit::kTenSeconds);
+    }
+  } else if (seconds < 100000) {
+    int64_t value = DivideRoundingUp(seconds, 100);
+    if ((value * 100) % kSecondsPerMinute != 0) {
+      return Timeout(value, Unit::kHundredSeconds);
     }
   }
+  return Timeout::FromMinutes(DivideRoundingUp(seconds, kSecondsPerMinute));
 }
 
-void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer) {
-  const grpc_millis kMaxTimeout = 99999999000;
-  if (timeout <= 0) {
-    enc_tiny(buffer);
-  } else if (timeout < 1000 * GPR_MS_PER_SEC) {
-    enc_millis(buffer, timeout);
-  } else if (timeout >= kMaxTimeout) {
-    enc_huge(buffer);
-  } else {
-    enc_seconds(buffer,
-                timeout / GPR_MS_PER_SEC + (timeout % GPR_MS_PER_SEC != 0));
+Timeout Timeout::FromMinutes(int64_t minutes) {
+  GPR_DEBUG_ASSERT(minutes != 0);
+  if (minutes < 1000) {
+    if (minutes % kMinutesPerHour != 0) {
+      return Timeout(minutes, Unit::kMinutes);
+    }
+  } else if (minutes < 10000) {
+    int64_t value = DivideRoundingUp(minutes, 10);
+    if ((value * 10) % kMinutesPerHour != 0) {
+      return Timeout(value, Unit::kTenMinutes);
+    }
+  } else if (minutes < 100000) {
+    int64_t value = DivideRoundingUp(minutes, 100);
+    if ((value * 100) % kMinutesPerHour != 0) {
+      return Timeout(value, Unit::kHundredMinutes);
+    }
   }
+  return Timeout::FromHours(DivideRoundingUp(minutes, kMinutesPerHour));
 }
 
-static int is_all_whitespace(const char* p, const char* end) {
-  while (p != end && *p == ' ') p++;
-  return p == end;
+Timeout Timeout::FromHours(int64_t hours) {
+  GPR_DEBUG_ASSERT(hours != 0);
+  if (hours < kMaxHours) {
+    return Timeout(hours, Unit::kHours);
+  }
+  return Timeout(kMaxHours, Unit::kHours);
 }
 
-int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout) {
+absl::optional<grpc_millis> ParseTimeout(const Slice& text) {
   grpc_millis x = 0;
-  const uint8_t* p = GRPC_SLICE_START_PTR(text);
-  const uint8_t* end = GRPC_SLICE_END_PTR(text);
+  const uint8_t* p = text.begin();
+  const uint8_t* end = text.end();
   int have_digit = 0;
   /* skip whitespace */
   for (; p != end && *p == ' '; p++) {
@@ -111,41 +243,43 @@ int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout) {
     /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
     if (x >= (100 * 1000 * 1000)) {
       if (x != (100 * 1000 * 1000) || digit != 0) {
-        *timeout = GRPC_MILLIS_INF_FUTURE;
-        return 1;
+        return GRPC_MILLIS_INF_FUTURE;
       }
     }
     x = x * 10 + digit;
   }
-  if (!have_digit) return 0;
+  if (!have_digit) return absl::nullopt;
   /* skip whitespace */
   for (; p != end && *p == ' '; p++) {
   }
-  if (p == end) return 0;
+  if (p == end) return absl::nullopt;
   /* decode unit specifier */
+  int64_t timeout;
   switch (*p) {
     case 'n':
-      *timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
+      timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
       break;
     case 'u':
-      *timeout = x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0);
+      timeout = x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0);
       break;
     case 'm':
-      *timeout = x;
+      timeout = x;
       break;
     case 'S':
-      *timeout = x * GPR_MS_PER_SEC;
+      timeout = x * GPR_MS_PER_SEC;
       break;
     case 'M':
-      *timeout = x * 60 * GPR_MS_PER_SEC;
+      timeout = x * 60 * GPR_MS_PER_SEC;
       break;
     case 'H':
-      *timeout = x * 60 * 60 * GPR_MS_PER_SEC;
+      timeout = x * 60 * 60 * GPR_MS_PER_SEC;
       break;
     default:
-      return 0;
+      return absl::nullopt;
   }
   p++;
-  return is_all_whitespace(reinterpret_cast<const char*>(p),
-                           reinterpret_cast<const char*>(end));
+  if (!IsAllSpace(p, end)) return absl::nullopt;
+  return timeout;
 }
+
+}  // namespace grpc_core