grpc 1.44.0.pre2 → 1.45.0

data/src/core/lib/http/httpcli.h

@@ -25,94 +25,199 @@
 
 #include <grpc/support/time.h>
 
+#include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
 
-/* TODO(ctiller): allow caching and capturing multiple requests for the
-                  same content and combining them */
-struct grpc_httpcli_handshaker {
-  const char* default_port;
-  void (*handshake)(void* arg, grpc_endpoint* endpoint, const char* host,
-                    grpc_millis deadline,
-                    void (*on_done)(void* arg, grpc_endpoint* endpoint));
-};
-extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
-extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
-
-/* A request */
-typedef struct grpc_httpcli_request {
-  /* The host name to connect to */
-  char* host;
-  /* The host to verify in the SSL handshake (or NULL) */
-  char* ssl_host_override;
-  /* The main part of the request
-     The following headers are supplied automatically and MUST NOT be set here:
-     Host, Connection, User-Agent */
-  grpc_http_request http;
-  /* handshaker to use ssl for the request */
-  const grpc_httpcli_handshaker* handshaker;
-} grpc_httpcli_request;
-
-/* Expose the parser response type as a httpcli response too */
-typedef struct grpc_http_response grpc_httpcli_response;
-
-/* Asynchronously perform a HTTP GET.
-   'pollent' indicates a grpc_polling_entity that is interested in the result
-     of the get - work on this entity may be used to progress the get
-     operation
-   'resource_quota' allows the caller to specify the quota against which to
-   allocate
-   'request' contains request parameters - these are caller owned and
-   can be destroyed once the call returns 'deadline' contains a deadline for the
-   request (or gpr_inf_future)
-   'on_response' is a callback to report results to */
-void grpc_httpcli_get(grpc_polling_entity* pollent,
-                      grpc_core::ResourceQuotaRefPtr resource_quota,
-                      const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_done, grpc_httpcli_response* response);
-
-/* Asynchronously perform a HTTP POST.
-   'pollent' indicates a grpc_polling_entity that is interested in the result
-     of the post - work on this entity may be used to progress the post
-     operation
-   'resource_quota' allows the caller to specify the quota against which to
-   allocate
-   'request' contains request parameters - these are caller owned and can be
-     destroyed once the call returns
-   'body_bytes' and 'body_size' specify the payload for the post.
-     When there is no body, pass in NULL as body_bytes.
-   'deadline' contains a deadline for the request (or gpr_inf_future)
-   'em' points to a caller owned event manager that must be alive for the
-     lifetime of the request
-   'on_response' is a callback to report results to
-   Does not support ?var1=val1&var2=val2 in the path. */
-void grpc_httpcli_post(grpc_polling_entity* pollent,
-                       grpc_core::ResourceQuotaRefPtr resource_quota,
-                       const grpc_httpcli_request* request,
-                       const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_done,
-                       grpc_httpcli_response* response);
-
 /* override functions return 1 if they handled the request, 0 otherwise */
-typedef int (*grpc_httpcli_get_override)(const grpc_httpcli_request* request,
-                                         grpc_millis deadline,
+typedef int (*grpc_httpcli_get_override)(const grpc_http_request* request,
+                                         const char* host, const char* path,
+                                         grpc_core::Timestamp deadline,
                                          grpc_closure* on_complete,
-                                         grpc_httpcli_response* response);
-typedef int (*grpc_httpcli_post_override)(const grpc_httpcli_request* request,
-                                          const char* body_bytes,
-                                          size_t body_size,
-                                          grpc_millis deadline,
-                                          grpc_closure* on_complete,
-                                          grpc_httpcli_response* response);
-
-void grpc_httpcli_set_override(grpc_httpcli_get_override get,
-                               grpc_httpcli_post_override post);
+                                         grpc_http_response* response);
+typedef int (*grpc_httpcli_post_override)(
+    const grpc_http_request* request, const char* host, const char* path,
+    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
+    grpc_closure* on_complete, grpc_http_response* response);
+
+namespace grpc_core {
+
+// Tracks an in-progress GET or POST request. Calling \a Start()
+// begins async work and calling \a Orphan() arranges for async work
+// to be completed as sooon as possible (possibly aborting the request
+// if it's in flight).
+// TODO(ctiller): allow caching and capturing multiple requests for the
+//                same content and combining them
+class HttpRequest : public InternallyRefCounted<HttpRequest> {
+ public:
+  // Asynchronously perform a HTTP GET.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the get - work on this entity may be used to progress the get
+  //   operation
+  // 'request' contains request parameters - these are caller owned and
+  //   can be destroyed once the call returns
+  // 'deadline' contains a deadline for the request (or gpr_inf_future)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(yihuaz): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  static OrphanablePtr<HttpRequest> Get(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
+  // Asynchronously perform a HTTP POST.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the post - work on this entity may be used to progress the post
+  //   operation
+  // 'request' contains request parameters - these are caller owned and can be
+  //   destroyed once the call returns
+  // 'deadline' contains a deadline for the request (or gpr_inf_future)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  // Does not support ?var1=val1&var2=val2 in the path.
+  static OrphanablePtr<HttpRequest> Post(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
+  HttpRequest(URI uri, const grpc_slice& request_text,
+              grpc_http_response* response, Timestamp deadline,
+              const grpc_channel_args* channel_args, grpc_closure* on_done,
+              grpc_polling_entity* pollent, const char* name,
+              absl::optional<std::function<void()>> test_only_generate_response,
+              RefCountedPtr<grpc_channel_credentials> channel_creds);
+
+  ~HttpRequest() override;
+
+  void Start();
+
+  void Orphan() override;
+
+  static void SetOverride(grpc_httpcli_get_override get,
+                          grpc_httpcli_post_override post);
+
+  static void TestOnlySetOnHandshakeDoneIntercept(
+      void (*intercept)(HttpRequest* req));
+
+ private:
+  void Finish(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    grpc_polling_entity_del_from_pollset_set(pollent_, pollset_set_);
+    ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
+  }
+
+  void AppendError(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void DoRead() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    Ref().release();  // ref held by pending read
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
+  }
+
+  static void OnRead(void* user_data, grpc_error_handle error) {
+    HttpRequest* req = static_cast<HttpRequest*>(user_data);
+    ExecCtx::Run(DEBUG_LOCATION,
+                 &req->continue_on_read_after_schedule_on_exec_ctx_,
+                 GRPC_ERROR_REF(error));
+  }
+
+  // Needed since OnRead may be called inline from grpc_endpoint_read
+  static void ContinueOnReadAfterScheduleOnExecCtx(void* user_data,
+                                                   grpc_error_handle error) {
+    RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(user_data));
+    MutexLock lock(&req->mu_);
+    req->OnReadInternal(error);
+  }
+
+  void OnReadInternal(grpc_error_handle error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void OnWritten() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { DoRead(); }
+
+  static void DoneWrite(void* arg, grpc_error_handle error) {
+    HttpRequest* req = static_cast<HttpRequest*>(arg);
+    ExecCtx::Run(DEBUG_LOCATION,
+                 &req->continue_done_write_after_schedule_on_exec_ctx_,
+                 GRPC_ERROR_REF(error));
+  }
+
+  // Needed since DoneWrite may be called inline from grpc_endpoint_write
+  static void ContinueDoneWriteAfterScheduleOnExecCtx(void* arg,
+                                                      grpc_error_handle error);
+
+  void StartWrite() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static void OnHandshakeDone(void* arg, grpc_error_handle error);
+
+  static void OnConnected(void* arg, grpc_error_handle error);
+
+  void NextAddress(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void OnResolved(
+      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
+
+  const URI uri_;
+  const grpc_slice request_text_;
+  const Timestamp deadline_;
+  const grpc_channel_args* channel_args_;
+  RefCountedPtr<grpc_channel_credentials> channel_creds_;
+  grpc_closure on_read_;
+  grpc_closure continue_on_read_after_schedule_on_exec_ctx_;
+  grpc_closure done_write_;
+  grpc_closure continue_done_write_after_schedule_on_exec_ctx_;
+  grpc_closure connected_;
+  grpc_endpoint* ep_ = nullptr;
+  grpc_closure* on_done_;
+  ResourceQuotaRefPtr resource_quota_;
+  grpc_polling_entity* pollent_;
+  grpc_pollset_set* pollset_set_;
+  const absl::optional<std::function<void()>> test_only_generate_response_;
+  Mutex mu_;
+  RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
+  bool own_endpoint_ ABSL_GUARDED_BY(mu_) = true;
+  bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
+  bool connecting_ ABSL_GUARDED_BY(mu_) = false;
+  grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
+  std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);
+  size_t next_address_ ABSL_GUARDED_BY(mu_) = 0;
+  int have_read_byte_ ABSL_GUARDED_BY(mu_) = 0;
+  grpc_iomgr_object iomgr_obj_ ABSL_GUARDED_BY(mu_);
+  grpc_slice_buffer incoming_ ABSL_GUARDED_BY(mu_);
+  grpc_slice_buffer outgoing_ ABSL_GUARDED_BY(mu_);
+  grpc_error_handle overall_error_ ABSL_GUARDED_BY(mu_) = GRPC_ERROR_NONE;
+  OrphanablePtr<DNSResolver::Request> dns_request_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_HTTP_HTTPCLI_H */

data/src/core/lib/http/httpcli_security_connector.cc

@@ -31,14 +31,18 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/ssl_transport_security.h"
 
+namespace grpc_core {
+
+namespace {
+
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
@@ -69,7 +73,7 @@ class grpc_httpcli_ssl_channel_security_connector final
 
   void add_handshakers(const grpc_channel_args* args,
                        grpc_pollset_set* /*interested_parties*/,
-                       grpc_core::HandshakeManager* handshake_mgr) override {
+                       HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
     if (handshaker_factory_ != nullptr) {
       tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
@@ -79,8 +83,7 @@ class grpc_httpcli_ssl_channel_security_connector final
                 tsi_result_to_string(result));
       }
     }
-    handshake_mgr->Add(
-        grpc_core::SecurityHandshakerCreate(handshaker, this, args));
+    handshake_mgr->Add(SecurityHandshakerCreate(handshaker, this, args));
   }
 
   tsi_ssl_client_handshaker_factory* handshaker_factory() const {
@@ -88,7 +91,7 @@ class grpc_httpcli_ssl_channel_security_connector final
   }
 
   void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
-                  grpc_core::RefCountedPtr<grpc_auth_context>* /*auth_context*/,
+                  RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error_handle error = GRPC_ERROR_NONE;
 
@@ -98,7 +101,7 @@ class grpc_httpcli_ssl_channel_security_connector final
       error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "Peer name ", secure_peer_name_, " is not in peer certificate"));
     }
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
+    ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
   }
 
@@ -114,17 +117,9 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(absl::string_view /*host*/,
-                       grpc_auth_context* /*auth_context*/,
-                       grpc_closure* /*on_call_host_checked*/,
-                       grpc_error_handle* error) override {
-    *error = GRPC_ERROR_NONE;
-    return true;
-  }
-
-  void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
-                              grpc_error_handle error) override {
-    GRPC_ERROR_UNREF(error);
+  ArenaPromise<absl::Status> CheckCallHost(absl::string_view,
+                                           grpc_auth_context*) override {
+    return ImmediateOkStatus();
   }
 
   const char* secure_peer_name() const { return secure_peer_name_; }
@@ -134,17 +129,17 @@ class grpc_httpcli_ssl_channel_security_connector final
   char* secure_peer_name_;
 };
 
-static grpc_core::RefCountedPtr<grpc_channel_security_connector>
+RefCountedPtr<grpc_channel_security_connector>
 httpcli_ssl_channel_security_connector_create(
     const char* pem_root_certs, const tsi_ssl_root_certs_store* root_store,
-    const char* secure_peer_name, grpc_channel_args* /*channel_args*/) {
+    const char* secure_peer_name) {
   if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR,
             "Cannot assert a secure peer name without a trust root.");
     return nullptr;
   }
-  grpc_core::RefCountedPtr<grpc_httpcli_ssl_channel_security_connector> c =
-      grpc_core::MakeRefCounted<grpc_httpcli_ssl_channel_security_connector>(
+  RefCountedPtr<grpc_httpcli_ssl_channel_security_connector> c =
+      MakeRefCounted<grpc_httpcli_ssl_channel_security_connector>(
           secure_peer_name == nullptr ? nullptr : gpr_strdup(secure_peer_name));
   tsi_result result = c->InitHandshakerFactory(pem_root_certs, root_store);
   if (result != TSI_OK) {
@@ -155,61 +150,55 @@ httpcli_ssl_channel_security_connector_create(
   return c;
 }
 
-/* handshaker */
+class HttpRequestSSLCredentials : public grpc_channel_credentials {
+ public:
+  HttpRequestSSLCredentials() : grpc_channel_credentials("HttpRequestSSL") {}
+  ~HttpRequestSSLCredentials() override {}
+
+  RefCountedPtr<grpc_channel_security_connector> create_security_connector(
+      RefCountedPtr<grpc_call_credentials> /*call_creds*/, const char* target,
+      const grpc_channel_args* args,
+      grpc_channel_args** /*new_args*/) override {
+    const char* pem_root_certs = DefaultSslRootStore::GetPemRootCerts();
+    const tsi_ssl_root_certs_store* root_store =
+        DefaultSslRootStore::GetRootStore();
+    if (root_store == nullptr) {
+      gpr_log(GPR_ERROR, "Could not get default pem root certs.");
+      return nullptr;
+    }
+    const char* ssl_host_override =
+        grpc_channel_args_find_string(args, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
+    if (ssl_host_override != nullptr) {
+      target = ssl_host_override;
+    }
+    return httpcli_ssl_channel_security_connector_create(pem_root_certs,
+                                                         root_store, target);
+  }
 
-struct on_done_closure {
-  void (*func)(void* arg, grpc_endpoint* endpoint);
-  void* arg;
-  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
-};
-static void on_handshake_done(void* arg, grpc_error_handle error) {
-  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
-  on_done_closure* c = static_cast<on_done_closure*>(args->user_data);
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "Secure transport setup failed: %s",
-            grpc_error_std_string(error).c_str());
-    c->func(c->arg, nullptr);
-  } else {
-    grpc_channel_args_destroy(args->args);
-    grpc_slice_buffer_destroy_internal(args->read_buffer);
-    gpr_free(args->read_buffer);
-    c->func(c->arg, args->endpoint);
+  RefCountedPtr<grpc_channel_credentials> duplicate_without_call_credentials()
+      override {
+    return Ref();
+  }
+
+  grpc_channel_args* update_arguments(grpc_channel_args* args) override {
+    return args;
   }
-  delete c;
-}
 
-static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
-                          grpc_millis deadline,
-                          void (*on_done)(void* arg, grpc_endpoint* endpoint)) {
-  auto* c = new on_done_closure();
-  const char* pem_root_certs =
-      grpc_core::DefaultSslRootStore::GetPemRootCerts();
-  const tsi_ssl_root_certs_store* root_store =
-      grpc_core::DefaultSslRootStore::GetRootStore();
-  if (root_store == nullptr) {
-    gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(arg, nullptr);
-    gpr_free(c);
-    return;
+ private:
+  int cmp_impl(const grpc_channel_credentials* /* other */) const override {
+    // There's no differentiating factor between two HttpRequestSSLCredentials
+    // objects.
+    return 0;
   }
-  c->func = on_done;
-  c->arg = arg;
-  grpc_core::RefCountedPtr<grpc_channel_security_connector> sc =
-      httpcli_ssl_channel_security_connector_create(
-          pem_root_certs, root_store, host,
-          static_cast<grpc_core::HandshakerArgs*>(arg)->args);
-
-  GPR_ASSERT(sc != nullptr);
-  grpc_arg channel_arg = grpc_security_connector_to_arg(sc.get());
-  grpc_channel_args args = {1, &channel_arg};
-  c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
-  grpc_core::CoreConfiguration::Get().handshaker_registry().AddHandshakers(
-      grpc_core::HANDSHAKER_CLIENT, &args,
-      /*interested_parties=*/nullptr, c->handshake_mgr.get());
-  c->handshake_mgr->DoHandshake(tcp, /*channel_args=*/nullptr, deadline,
-                                /*acceptor=*/nullptr, on_handshake_done,
-                                /*user_data=*/c);
-  sc.reset(DEBUG_LOCATION, "httpcli");
+};
+
+}  // namespace
+
+RefCountedPtr<grpc_channel_credentials> CreateHttpRequestSSLCredentials() {
+  // Create a singleton object for HttpRequestSSLCredentials so that channels to
+  // the same target with HttpRequestSSLCredentials can reuse the subchannels.
+  static auto* creds = new HttpRequestSSLCredentials();
+  return creds->Ref();
 }
 
-const grpc_httpcli_handshaker grpc_httpcli_ssl = {"https", ssl_handshake};
+}  // namespace grpc_core

data/src/core/lib/http/httpcli_ssl_credentials.h

@@ -0,0 +1,37 @@
+//
+// Copyright 2015 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_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+#define GRPC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/security/credentials/credentials.h"
+
+namespace grpc_core {
+
+// Creates a channel credentials suitable for use with the
+// HttpRequest::Get and HttpRequest::Post APIs. Notably, this allows
+// HTTP1 requests to use secure connections without ALPN (as the
+// typical gRPC SSL credentials do).
+//
+// These credentials are NOT INTENDED FOR USE with gRPC channels, and
+// MUST ONLY BE USED with the HttpRequest::Get and Post APIs.
+RefCountedPtr<grpc_channel_credentials> CreateHttpRequestSSLCredentials();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H

data/src/core/lib/http/parser.h

@@ -56,7 +56,7 @@ typedef enum {
 typedef struct grpc_http_request {
   /* Method of the request (e.g. GET, POST) */
   char* method;
-  /* The path of the resource to fetch */
+  /* The path of the resource to fetch (only used for parsed requests) */
   char* path;
   /* HTTP version to use */
   grpc_http_version version;

data/src/core/lib/iomgr/buffer_list.h

@@ -82,16 +82,16 @@ struct ConnectionMetrics {
   absl::optional<uint64_t> sndbuf_limited_usec;
 };
 
-struct Timestamp {
+struct BufferTimestamp {
   gpr_timespec time;
   ConnectionMetrics metrics; /* Metrics collected with this timestamp */
 };
 
 struct Timestamps {
-  Timestamp sendmsg_time;
-  Timestamp scheduled_time;
-  Timestamp sent_time;
-  Timestamp acked_time;
+  BufferTimestamp sendmsg_time;
+  BufferTimestamp scheduled_time;
+  BufferTimestamp sent_time;
+  BufferTimestamp acked_time;
 
   uint32_t byte_offset; /* byte offset relative to the start of the RPC */
 

data/src/core/lib/iomgr/error.cc

@@ -35,7 +35,6 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/error_internal.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_utils.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_error_refcount(false,
                                                         "error_refcount");
@@ -86,7 +85,7 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
                             const char* call_name) {
   char* utf8_message = gpr_format_message(err);
   absl::Status s =
-      StatusCreate(absl::StatusCode::kUnknown, "WSA Error", location, {});
+      StatusCreate(absl::StatusCode::kUnavailable, "WSA Error", location, {});
   StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
@@ -252,8 +251,6 @@ static const char* error_int_name(grpc_error_ints key) {
       return "channel_connectivity_state";
     case GRPC_ERROR_INT_LB_POLICY_DROP:
       return "lb_policy_drop";
-    case GRPC_ERROR_INT_STREAM_NETWORK_STATE:
-      return "stream_network_state";
     case GRPC_ERROR_INT_MAX:
       GPR_UNREACHABLE_CODE(return "unknown");
   }
@@ -448,6 +445,8 @@ static void internal_set_time(grpc_error_handle* err, grpc_error_times which,
   memcpy((*err)->arena + slot, &value, sizeof(value));
 }
 
+const char* grpc_error_string(grpc_error_handle err);
+
 static void internal_add_error(grpc_error_handle* err,
                                grpc_error_handle new_err) {
   grpc_linked_error new_last = {new_err, UINT8_MAX};
@@ -961,15 +960,17 @@ grpc_error_handle grpc_os_error(const char* file, int line, int err,
 grpc_error_handle grpc_wsa_error(const char* file, int line, int err,
                                  const char* call_name) {
   char* utf8_message = gpr_format_message(err);
-  grpc_error_handle error = grpc_error_set_str(
+  grpc_error_handle error = grpc_error_set_int(
       grpc_error_set_str(
-          grpc_error_set_int(
-              grpc_error_create(file, line,
-                                grpc_slice_from_static_string("OS Error"), NULL,
-                                0),
-              GRPC_ERROR_INT_WSA_ERROR, err),
-          GRPC_ERROR_STR_OS_ERROR, utf8_message),
-      GRPC_ERROR_STR_SYSCALL, call_name);
+          grpc_error_set_str(
+              grpc_error_set_int(
+                  grpc_error_create(file, line,
+                                    grpc_slice_from_static_string("OS Error"),
+                                    NULL, 0),
+                  GRPC_ERROR_INT_WSA_ERROR, err),
+              GRPC_ERROR_STR_OS_ERROR, utf8_message),
+          GRPC_ERROR_STR_SYSCALL, call_name),
+      GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
   gpr_free(utf8_message);
   return error;
 }

data/src/core/lib/iomgr/error.h

@@ -96,9 +96,6 @@ typedef enum {
   /// LB policy drop
   GRPC_ERROR_INT_LB_POLICY_DROP =
       static_cast<int>(grpc_core::StatusIntProperty::kLbPolicyDrop),
-  /// stream network state
-  GRPC_ERROR_INT_STREAM_NETWORK_STATE =
-      static_cast<int>(grpc_core::StatusIntProperty::kStreamNetworkState),
 
   /// Must always be last
   GRPC_ERROR_INT_MAX,
@@ -148,8 +145,6 @@ typedef enum {
   GRPC_ERROR_TIME_MAX,
 } grpc_error_times;
 
-// DEPRECATED: Use grpc_error_std_string instead
-const char* grpc_error_string(grpc_error_handle error);
 std::string grpc_error_std_string(grpc_error_handle error);
 
 // debug only toggles that allow for a sanity to check that ensures we will

data/src/core/lib/iomgr/ev_apple.cc

@@ -221,9 +221,10 @@ static void pollset_global_shutdown(void) {
 /// these events will eventually trigger the kick.
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64,
-                     pollset, worker, deadline);
+                     pollset, worker,
+                     deadline.milliseconds_after_process_epoch());
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   GrpcAppleWorker actual_worker;
@@ -241,8 +242,8 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 
     while (!actual_worker.kicked && !apple_pollset->is_shutdown) {
       if (actual_worker.cv.WaitWithDeadline(
-              &apple_pollset->mu, grpc_core::ToAbslTime(grpc_millis_to_timespec(
-                                      deadline, GPR_CLOCK_REALTIME)))) {
+              &apple_pollset->mu, grpc_core::ToAbslTime(deadline.as_timespec(
+                                      GPR_CLOCK_REALTIME)))) {
         // timed out
         break;
       }
@@ -313,7 +314,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   apple_pollset->is_shutdown = true;
-  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
+  (void)pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
 
   // If there is any worker blocked, shutdown will be done asynchronously.
   if (apple_pollset->workers.empty()) {