grpc 1.42.0 → 1.51.0

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

@@ -0,0 +1,246 @@
+//
+//
+// Copyright 2022 gRPC 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
+//
+//     http://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 <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/tcp_connect_handshaker.h"
+
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/iomgr/tcp_client.h"
+#include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/transport/handshaker_factory.h"
+#include "src/core/lib/transport/handshaker_registry.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+namespace {
+
+class TCPConnectHandshaker : public Handshaker {
+ public:
+  explicit TCPConnectHandshaker(grpc_pollset_set* pollset_set);
+  void Shutdown(grpc_error_handle why) override;
+  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                   grpc_closure* on_handshake_done,
+                   HandshakerArgs* args) override;
+  const char* name() const override { return "tcp_connect"; }
+
+ private:
+  ~TCPConnectHandshaker() override;
+  void CleanupArgsForFailureLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void FinishLocked(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void Connected(void* arg, grpc_error_handle error);
+
+  Mutex mu_;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // Endpoint and read buffer to destroy after a shutdown.
+  grpc_endpoint* endpoint_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_slice_buffer* read_buffer_to_destroy_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_closure* on_handshake_done_ ABSL_GUARDED_BY(mu_) = nullptr;
+  grpc_pollset_set* interested_parties_ = nullptr;
+  grpc_polling_entity pollent_;
+  HandshakerArgs* args_ = nullptr;
+  bool bind_endpoint_to_pollset_ = false;
+  grpc_resolved_address addr_;
+  grpc_closure connected_;
+};
+
+TCPConnectHandshaker::TCPConnectHandshaker(grpc_pollset_set* pollset_set)
+    : interested_parties_(grpc_pollset_set_create()),
+      pollent_(grpc_polling_entity_create_from_pollset_set(pollset_set)) {
+  // Interested parties might be null for platforms like Apple.
+  // Explicitly check before adding/deleting from pollset_set to handle this
+  // use case.
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_add_to_pollset_set(&pollent_, interested_parties_);
+  }
+  GRPC_CLOSURE_INIT(&connected_, Connected, this, grpc_schedule_on_exec_ctx);
+}
+
+void TCPConnectHandshaker::Shutdown(grpc_error_handle /*why*/) {
+  // TODO(anramach): After migration to EventEngine, cancel the in-progress
+  // TCP connection attempt.
+  {
+    MutexLock lock(&mu_);
+    if (!shutdown_) {
+      shutdown_ = true;
+      // If we are shutting down while connecting, respond back with
+      // handshake done.
+      // The callback from grpc_tcp_client_connect will perform
+      // the necessary clean up.
+      if (on_handshake_done_ != nullptr) {
+        CleanupArgsForFailureLocked();
+        FinishLocked(GRPC_ERROR_CREATE("tcp handshaker shutdown"));
+      }
+    }
+  }
+}
+
+void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
+                                       grpc_closure* on_handshake_done,
+                                       HandshakerArgs* args) {
+  {
+    MutexLock lock(&mu_);
+    on_handshake_done_ = on_handshake_done;
+  }
+  GPR_ASSERT(args->endpoint == nullptr);
+  args_ = args;
+  absl::StatusOr<URI> uri = URI::Parse(
+      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
+  if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
+    MutexLock lock(&mu_);
+    FinishLocked(GRPC_ERROR_CREATE("Resolved address in invalid format"));
+    return;
+  }
+  bind_endpoint_to_pollset_ =
+      args->args.GetBool(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET)
+          .value_or(false);
+  // Update args to not contain the args relevant to TCP connect handshaker.
+  args->args = args->args.Remove(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS)
+                   .Remove(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET);
+  // In some implementations, the closure can be flushed before
+  // grpc_tcp_client_connect() returns, and since the closure requires access
+  // to mu_, this can result in a deadlock (see
+  // https://github.com/grpc/grpc/issues/16427 for details).
+  // grpc_tcp_client_connect() will fill endpoint_ with proper contents, and we
+  // make sure that we still exist at that point by taking a ref.
+  Ref().release();  // Ref held by callback.
+  // As we fake the TCP client connection failure when shutdown is called
+  // we don't want to pass args->endpoint directly.
+  // Instead pass endpoint_ and swap this endpoint to
+  // args endpoint on success.
+  // TODO(hork): use EventEngine::Connect if(IsEventEngineClientEnabled())
+  grpc_tcp_client_connect(
+      &connected_, &endpoint_to_destroy_, interested_parties_,
+      grpc_event_engine::experimental::ChannelArgsEndpointConfig(args->args),
+      &addr_, args->deadline);
+}
+
+void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
+  RefCountedPtr<TCPConnectHandshaker> self(
+      static_cast<TCPConnectHandshaker*>(arg));
+  {
+    MutexLock lock(&self->mu_);
+    if (!error.ok() || self->shutdown_) {
+      if (error.ok()) {
+        error = GRPC_ERROR_CREATE("tcp handshaker shutdown");
+      }
+      if (self->endpoint_to_destroy_ != nullptr) {
+        grpc_endpoint_shutdown(self->endpoint_to_destroy_, error);
+      }
+      if (!self->shutdown_) {
+        self->CleanupArgsForFailureLocked();
+        self->shutdown_ = true;
+        self->FinishLocked(error);
+      } else {
+        // The on_handshake_done_ is already as part of shutdown when
+        // connecting So nothing to be done here other than unrefing the
+        // error.
+      }
+      return;
+    }
+    GPR_ASSERT(self->endpoint_to_destroy_ != nullptr);
+    self->args_->endpoint = self->endpoint_to_destroy_;
+    self->endpoint_to_destroy_ = nullptr;
+    if (self->bind_endpoint_to_pollset_) {
+      grpc_endpoint_add_to_pollset_set(self->args_->endpoint,
+                                       self->interested_parties_);
+    }
+    self->FinishLocked(absl::OkStatus());
+  }
+}
+
+TCPConnectHandshaker::~TCPConnectHandshaker() {
+  if (endpoint_to_destroy_ != nullptr) {
+    grpc_endpoint_destroy(endpoint_to_destroy_);
+  }
+  if (read_buffer_to_destroy_ != nullptr) {
+    grpc_slice_buffer_destroy(read_buffer_to_destroy_);
+    gpr_free(read_buffer_to_destroy_);
+  }
+  grpc_pollset_set_destroy(interested_parties_);
+}
+
+void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
+  read_buffer_to_destroy_ = args_->read_buffer;
+  args_->read_buffer = nullptr;
+  args_->args = ChannelArgs();
+}
+
+void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
+  if (interested_parties_ != nullptr) {
+    grpc_polling_entity_del_from_pollset_set(&pollent_, interested_parties_);
+  }
+  ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, error);
+  on_handshake_done_ = nullptr;
+}
+
+//
+// TCPConnectHandshakerFactory
+//
+
+class TCPConnectHandshakerFactory : public HandshakerFactory {
+ public:
+  void AddHandshakers(const ChannelArgs& /*args*/,
+                      grpc_pollset_set* interested_parties,
+                      HandshakeManager* handshake_mgr) override {
+    handshake_mgr->Add(
+        MakeRefCounted<TCPConnectHandshaker>(interested_parties));
+  }
+  HandshakerPriority Priority() override {
+    return HandshakerPriority::kTCPConnectHandshakers;
+  }
+  ~TCPConnectHandshakerFactory() override = default;
+};
+
+}  // namespace
+
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder) {
+  builder->handshaker_registry()->RegisterHandshakerFactory(
+      HANDSHAKER_CLIENT, std::make_unique<TCPConnectHandshakerFactory>());
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,39 @@
+//
+// Copyright 2022 gRPC 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
+//
+//     http://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 GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+#define GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/config/core_configuration.h"
+
+// Indicates the address that the tcp connect handshaker should connect to.
+#define GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS \
+  "grpc.internal.tcp_handshaker_resolved_address"
+
+// Whether the TCP connect handshaker should bind the endpoint to the pollset.
+#define GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET \
+  "grpc.internal.tcp_handshaker_bind_endpoint_to_pollset"
+
+namespace grpc_core {
+
+// Register the TCP Connect handshaker into the configuration builder.
+void RegisterTCPConnectHandshaker(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_TRANSPORT_TCP_CONNECT_HANDSHAKER_H

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

@@ -20,86 +20,215 @@
 
 #include "src/core/lib/transport/timeout_encoding.h"
 
-#include <stdio.h>
-#include <string.h>
+#include "absl/base/attributes.h"
 
-#include "src/core/lib/gpr/string.h"
+#include <grpc/support/log.h>
+#include <grpc/support/time.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 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(Duration duration) {
+  return Timeout::FromMillis(duration.millis());
+}
 
-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().millis();
+  double b = other.AsDuration().millis();
+  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');
+Duration Timeout::AsDuration() const {
+  int64_t value = value_;
+  switch (unit_) {
+    case Unit::kNanoseconds:
+      return Duration::Zero();
+    case Unit::kMilliseconds:
+      return Duration::Milliseconds(value);
+    case Unit::kTenMilliseconds:
+      return Duration::Milliseconds(value * 10);
+    case Unit::kHundredMilliseconds:
+      return Duration::Milliseconds(value * 100);
+    case Unit::kSeconds:
+      return Duration::Seconds(value);
+    case Unit::kTenSeconds:
+      return Duration::Seconds(value * 10);
+    case Unit::kHundredSeconds:
+      return Duration::Seconds(value * 100);
+    case Unit::kMinutes:
+      return Duration::Minutes(value);
+    case Unit::kTenMinutes:
+      return Duration::Minutes(value * 10);
+    case Unit::kHundredMinutes:
+      return Duration::Minutes(value * 100);
+    case Unit::kHours:
+      return Duration::Hours(value);
   }
+  GPR_UNREACHABLE_CODE(return Duration::NegativeInfinity());
 }
 
-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) {
-  grpc_millis x = 0;
-  const uint8_t* p = GRPC_SLICE_START_PTR(text);
-  const uint8_t* end = GRPC_SLICE_END_PTR(text);
+absl::optional<Duration> ParseTimeout(const Slice& text) {
+  int32_t x = 0;
+  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 +240,45 @@ 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 Duration::Infinity();
       }
     }
     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 */
+  Duration timeout;
   switch (*p) {
     case 'n':
-      *timeout = x / GPR_NS_PER_MS + (x % GPR_NS_PER_MS != 0);
+      timeout =
+          Duration::Milliseconds(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 =
+          Duration::Milliseconds(x / GPR_US_PER_MS + (x % GPR_US_PER_MS != 0));
       break;
     case 'm':
-      *timeout = x;
+      timeout = Duration::Milliseconds(x);
       break;
     case 'S':
-      *timeout = x * GPR_MS_PER_SEC;
+      timeout = Duration::Seconds(x);
       break;
     case 'M':
-      *timeout = x * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Minutes(x);
       break;
     case 'H':
-      *timeout = x * 60 * 60 * GPR_MS_PER_SEC;
+      timeout = Duration::Hours(x);
       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

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

@@ -21,18 +21,52 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
-#include <grpc/support/time.h>
+#include <stdint.h>
 
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "absl/types/optional.h"
 
-#define GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE 10
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/slice/slice.h"
 
-/* Encode/decode timeouts to the GRPC over HTTP/2 format;
-   encoding may round up arbitrarily. If the timeout is larger than about 1157
-   days, it will be capped and "99999999S" will be sent on the wire. */
-void grpc_http2_encode_timeout(grpc_millis timeout, char* buffer);
-int grpc_http2_decode_timeout(const grpc_slice& text, grpc_millis* timeout);
+namespace grpc_core {
+
+class Timeout {
+ public:
+  static Timeout FromDuration(Duration duration);
+
+  // Computes: 100 * ((this - other) / other)
+  double RatioVersus(Timeout other) const;
+  Slice Encode() const;
+  Duration AsDuration() const;
+
+ private:
+  enum class Unit : uint8_t {
+    kNanoseconds,
+    kMilliseconds,
+    kTenMilliseconds,
+    kHundredMilliseconds,
+    kSeconds,
+    kTenSeconds,
+    kHundredSeconds,
+    kMinutes,
+    kTenMinutes,
+    kHundredMinutes,
+    kHours,
+  };
+
+  Timeout(uint16_t value, Unit unit) : value_(value), unit_(unit) {}
+
+  static Timeout FromMillis(int64_t millis);
+  static Timeout FromSeconds(int64_t seconds);
+  static Timeout FromMinutes(int64_t minutes);
+  static Timeout FromHours(int64_t hours);
+
+  uint16_t value_;
+  Unit unit_;
+};
+
+absl::optional<Duration> ParseTimeout(const Slice& text);
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TIMEOUT_ENCODING_H */