grpc 1.47.0 → 1.53.0

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -1,41 +1,70 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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/ext/transport/inproc/inproc_transport.h"
 
-#include <string.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <memory>
+#include <new>
+#include <string>
+#include <utility>
 
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
-#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/resource_quota/api.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.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/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 #define INPROC_LOG(...)                               \
@@ -53,8 +82,11 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error);
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial);
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
-                      uint32_t flags, grpc_metadata_batch* out_md,
-                      uint32_t* outflags, bool* markfilled);
+                      grpc_metadata_batch* out_md, bool* markfilled);
+
+void ResetSendMessage(grpc_transport_stream_op_batch* batch) {
+  std::exchange(batch->payload->send_message.send_message, nullptr)->Clear();
+}
 
 struct shared_mu {
   shared_mu() {
@@ -160,24 +192,21 @@ struct inproc_stream {
       // Now transfer from the other side's write_buffer if any to the to_read
       // buffer
       if (cs->write_buffer_initial_md_filled) {
-        (void)fill_in_metadata(this, &cs->write_buffer_initial_md,
-                               cs->write_buffer_initial_md_flags,
-                               &to_read_initial_md, &to_read_initial_md_flags,
-                               &to_read_initial_md_filled);
+        fill_in_metadata(this, &cs->write_buffer_initial_md,
+                         &to_read_initial_md, &to_read_initial_md_filled);
         deadline = std::min(deadline, cs->write_buffer_deadline);
         cs->write_buffer_initial_md.Clear();
         cs->write_buffer_initial_md_filled = false;
       }
       if (cs->write_buffer_trailing_md_filled) {
-        (void)fill_in_metadata(this, &cs->write_buffer_trailing_md, 0,
-                               &to_read_trailing_md, nullptr,
-                               &to_read_trailing_md_filled);
+        fill_in_metadata(this, &cs->write_buffer_trailing_md,
+                         &to_read_trailing_md, &to_read_trailing_md_filled);
         cs->write_buffer_trailing_md.Clear();
         cs->write_buffer_trailing_md_filled = false;
       }
-      if (cs->write_buffer_cancel_error != GRPC_ERROR_NONE) {
+      if (!cs->write_buffer_cancel_error.ok()) {
         cancel_other_error = cs->write_buffer_cancel_error;
-        cs->write_buffer_cancel_error = GRPC_ERROR_NONE;
+        cs->write_buffer_cancel_error = absl::OkStatus();
         maybe_process_ops_locked(this, cancel_other_error);
       }
 
@@ -185,17 +214,7 @@ struct inproc_stream {
     }
   }
 
-  ~inproc_stream() {
-    GRPC_ERROR_UNREF(write_buffer_cancel_error);
-    GRPC_ERROR_UNREF(cancel_self_error);
-    GRPC_ERROR_UNREF(cancel_other_error);
-
-    if (recv_inited) {
-      grpc_slice_buffer_destroy_internal(&recv_message);
-    }
-
-    t->unref();
-  }
+  ~inproc_stream() { t->unref(); }
 
 #ifndef NDEBUG
 #define STREAM_REF(refs, reason) grpc_stream_ref(refs, reason)
@@ -221,7 +240,6 @@ struct inproc_stream {
   grpc_core::Arena* arena;
 
   grpc_metadata_batch to_read_initial_md{arena};
-  uint32_t to_read_initial_md_flags = 0;
   bool to_read_initial_md_filled = false;
   grpc_metadata_batch to_read_trailing_md{arena};
   bool to_read_trailing_md_filled = false;
@@ -230,12 +248,11 @@ struct inproc_stream {
   // stream is set up but server side stream is not yet set up
   grpc_metadata_batch write_buffer_initial_md{arena};
   bool write_buffer_initial_md_filled = false;
-  uint32_t write_buffer_initial_md_flags = 0;
   grpc_core::Timestamp write_buffer_deadline =
       grpc_core::Timestamp::InfFuture();
   grpc_metadata_batch write_buffer_trailing_md{arena};
   bool write_buffer_trailing_md_filled = false;
-  grpc_error_handle write_buffer_cancel_error = GRPC_ERROR_NONE;
+  grpc_error_handle write_buffer_cancel_error;
 
   struct inproc_stream* other_side;
   bool other_side_closed = false;               // won't talk anymore
@@ -247,10 +264,6 @@ struct inproc_stream {
   grpc_transport_stream_op_batch* recv_message_op = nullptr;
   grpc_transport_stream_op_batch* recv_trailing_md_op = nullptr;
 
-  grpc_slice_buffer recv_message;
-  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> recv_stream;
-  bool recv_inited = false;
-
   bool initial_md_sent = false;
   bool trailing_md_sent = false;
   bool initial_md_recvd = false;
@@ -263,8 +276,8 @@ struct inproc_stream {
 
   bool closed = false;
 
-  grpc_error_handle cancel_self_error = GRPC_ERROR_NONE;
-  grpc_error_handle cancel_other_error = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_self_error;
+  grpc_error_handle cancel_other_error;
 
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
@@ -310,22 +323,19 @@ class CopySink {
 }  // namespace
 
 void fill_in_metadata(inproc_stream* s, const grpc_metadata_batch* metadata,
-                      uint32_t flags, grpc_metadata_batch* out_md,
-                      uint32_t* outflags, bool* markfilled) {
+                      grpc_metadata_batch* out_md, bool* markfilled) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
-    log_metadata(metadata, s->t->is_client, outflags != nullptr);
+    log_metadata(metadata, s->t->is_client,
+                 metadata->get_pointer(grpc_core::WaitForReady()) != nullptr);
   }
 
-  if (outflags != nullptr) {
-    *outflags = flags;
-  }
   if (markfilled != nullptr) {
     *markfilled = true;
   }
 
   // TODO(ctiller): copy the metadata batch, don't rely on a bespoke copy
-  // function. Can only do this once mdelems are out of the way though, too many
-  // edge cases otherwise.
+  // function. Can only do this once mdelems are out of the way though, too
+  // many edge cases otherwise.
   out_md->Clear();
   CopySink sink(out_md);
   metadata->Encode(&sink);
@@ -399,14 +409,13 @@ void complete_if_batch_end_locked(inproc_stream* s, grpc_error_handle error,
 
   if ((is_sm + is_stm + is_rim + is_rm + is_rtm) == 1) {
     INPROC_LOG(GPR_INFO, "%s %p %p %s", msg, s, op,
-               grpc_error_std_string(error).c_str());
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_complete,
-                            GRPC_ERROR_REF(error));
+               grpc_core::StatusToString(error).c_str());
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_complete, error);
   }
 }
 
 void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error) {
-  if (s && (error != GRPC_ERROR_NONE || s->ops_needed)) {
+  if (s && (!error.ok() || s->ops_needed)) {
     s->ops_needed = false;
     op_state_machine_locked(s, error);
   }
@@ -427,37 +436,35 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    (void)fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
+    fill_in_metadata(s, &fake_md, dest, destfilled);
 
     if (other != nullptr) {
-      if (other->cancel_other_error == GRPC_ERROR_NONE) {
-        other->cancel_other_error = GRPC_ERROR_REF(error);
+      if (other->cancel_other_error.ok()) {
+        other->cancel_other_error = error;
       }
       maybe_process_ops_locked(other, error);
-    } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
-      s->write_buffer_cancel_error = GRPC_ERROR_REF(error);
+    } else if (s->write_buffer_cancel_error.ok()) {
+      s->write_buffer_cancel_error = error;
     }
   }
   if (s->recv_initial_md_op) {
     grpc_error_handle err;
     if (!s->t->is_client) {
-      // If this is a server, provide initial metadata with a path and authority
-      // since it expects that as well as no error yet
+      // If this is a server, provide initial metadata with a path and
+      // authority since it expects that as well as no error yet
       grpc_metadata_batch fake_md(s->arena);
       fake_md.Set(grpc_core::HttpPathMetadata(),
                   grpc_core::Slice::FromStaticString("/"));
       fake_md.Set(grpc_core::HttpAuthorityMetadata(),
                   grpc_core::Slice::FromStaticString("inproc-fail"));
 
-      (void)fill_in_metadata(
-          s, &fake_md, 0,
-          s->recv_initial_md_op->payload->recv_initial_metadata
-              .recv_initial_metadata,
-          s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          nullptr);
-      err = GRPC_ERROR_NONE;
+      fill_in_metadata(s, &fake_md,
+                       s->recv_initial_md_op->payload->recv_initial_metadata
+                           .recv_initial_metadata,
+                       nullptr);
+      err = absl::OkStatus();
     } else {
-      err = GRPC_ERROR_REF(error);
+      err = error;
     }
     if (s->recv_initial_md_op->payload->recv_initial_metadata
             .trailing_metadata_available != nullptr) {
@@ -469,8 +476,8 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     }
     INPROC_LOG(GPR_INFO,
                "fail_helper %p scheduling initial-metadata-ready %s %s", s,
-               grpc_error_std_string(error).c_str(),
-               grpc_error_std_string(err).c_str());
+               grpc_core::StatusToString(error).c_str(),
+               grpc_core::StatusToString(err).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_initial_md_op->payload->recv_initial_metadata
@@ -485,7 +492,7 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
   }
   if (s->recv_message_op) {
     INPROC_LOG(GPR_INFO, "fail_helper %p scheduling message-ready %s", s,
-               grpc_error_std_string(error).c_str());
+               grpc_core::StatusToString(error).c_str());
     if (s->recv_message_op->payload->recv_message
             .call_failed_before_recv_message != nullptr) {
       *s->recv_message_op->payload->recv_message
@@ -493,15 +500,14 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     }
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
-        s->recv_message_op->payload->recv_message.recv_message_ready,
-        GRPC_ERROR_REF(error));
+        s->recv_message_op->payload->recv_message.recv_message_ready, error);
     complete_if_batch_end_locked(
         s, error, s->recv_message_op,
         "fail_helper scheduling recv-message-on-complete");
     s->recv_message_op = nullptr;
   }
   if (s->send_message_op) {
-    s->send_message_op->payload->send_message.send_message.reset();
+    ResetSendMessage(s->send_message_op);
     complete_if_batch_end_locked(
         s, error, s->send_message_op,
         "fail_helper scheduling send-message-on-complete");
@@ -515,14 +521,14 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
   }
   if (s->recv_trailing_md_op) {
     INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-metadata-ready %s",
-               s, grpc_error_std_string(error).c_str());
+               s, grpc_core::StatusToString(error).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_trailing_md_op->payload->recv_trailing_metadata
             .recv_trailing_metadata_ready,
-        GRPC_ERROR_REF(error));
+        error);
     INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-md-on-complete %s",
-               s, grpc_error_std_string(error).c_str());
+               s, grpc_core::StatusToString(error).c_str());
     complete_if_batch_end_locked(
         s, error, s->recv_trailing_md_op,
         "fail_helper scheduling recv-trailing-metadata-on-complete");
@@ -530,8 +536,6 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
   }
   close_other_side_locked(s, "fail_helper:other_side");
   close_stream_locked(s);
-
-  GRPC_ERROR_UNREF(error);
 }
 
 // TODO(vjpai): It should not be necessary to drain the incoming byte
@@ -543,46 +547,22 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
 // synchronously.  That assumption is true today but may not always be
 // true in the future.
 void message_transfer_locked(inproc_stream* sender, inproc_stream* receiver) {
-  size_t remaining =
-      sender->send_message_op->payload->send_message.send_message->length();
-  if (receiver->recv_inited) {
-    grpc_slice_buffer_destroy_internal(&receiver->recv_message);
-  }
-  grpc_slice_buffer_init(&receiver->recv_message);
-  receiver->recv_inited = true;
-  do {
-    grpc_slice message_slice;
-    grpc_closure unused;
-    GPR_ASSERT(
-        sender->send_message_op->payload->send_message.send_message->Next(
-            SIZE_MAX, &unused));
-    grpc_error_handle error =
-        sender->send_message_op->payload->send_message.send_message->Pull(
-            &message_slice);
-    if (error != GRPC_ERROR_NONE) {
-      cancel_stream_locked(sender, GRPC_ERROR_REF(error));
-      break;
-    }
-    GPR_ASSERT(error == GRPC_ERROR_NONE);
-    remaining -= GRPC_SLICE_LENGTH(message_slice);
-    grpc_slice_buffer_add(&receiver->recv_message, message_slice);
-  } while (remaining > 0);
-  sender->send_message_op->payload->send_message.send_message.reset();
-
-  receiver->recv_stream.Init(&receiver->recv_message, 0);
-  receiver->recv_message_op->payload->recv_message.recv_message->reset(
-      receiver->recv_stream.get());
+  *receiver->recv_message_op->payload->recv_message.recv_message =
+      std::move(*sender->send_message_op->payload->send_message.send_message);
+  *receiver->recv_message_op->payload->recv_message.flags =
+      sender->send_message_op->payload->send_message.flags;
+
   INPROC_LOG(GPR_INFO, "message_transfer_locked %p scheduling message-ready",
              receiver);
   grpc_core::ExecCtx::Run(
       DEBUG_LOCATION,
       receiver->recv_message_op->payload->recv_message.recv_message_ready,
-      GRPC_ERROR_NONE);
+      absl::OkStatus());
   complete_if_batch_end_locked(
-      sender, GRPC_ERROR_NONE, sender->send_message_op,
+      sender, absl::OkStatus(), sender->send_message_op,
       "message_transfer scheduling sender on_complete");
   complete_if_batch_end_locked(
-      receiver, GRPC_ERROR_NONE, receiver->recv_message_op,
+      receiver, absl::OkStatus(), receiver->recv_message_op,
       "message_transfer scheduling receiver on_complete");
 
   receiver->recv_message_op = nullptr;
@@ -595,7 +575,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   // Schedule our appropriate closures
   // and then return to ops_needed state if still needed
 
-  grpc_error_handle new_err = GRPC_ERROR_NONE;
+  grpc_error_handle new_err;
 
   bool needs_close = false;
 
@@ -603,26 +583,26 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   // cancellation takes precedence
   inproc_stream* other = s->other_side;
 
-  if (s->cancel_self_error != GRPC_ERROR_NONE) {
-    fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_self_error));
+  if (!s->cancel_self_error.ok()) {
+    fail_helper_locked(s, s->cancel_self_error);
     goto done;
-  } else if (s->cancel_other_error != GRPC_ERROR_NONE) {
-    fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_other_error));
+  } else if (!s->cancel_other_error.ok()) {
+    fail_helper_locked(s, s->cancel_other_error);
     goto done;
-  } else if (error != GRPC_ERROR_NONE) {
-    fail_helper_locked(s, GRPC_ERROR_REF(error));
+  } else if (!error.ok()) {
+    fail_helper_locked(s, error);
     goto done;
   }
 
   if (s->send_message_op && other) {
     if (other->recv_message_op) {
       message_transfer_locked(s, other);
-      maybe_process_ops_locked(other, GRPC_ERROR_NONE);
+      maybe_process_ops_locked(other, absl::OkStatus());
     } else if (!s->t->is_client && s->trailing_md_sent) {
       // A server send will never be matched if the server already sent status
-      s->send_message_op->payload->send_message.send_message.reset();
+      ResetSendMessage(s->send_message_op);
       complete_if_batch_end_locked(
-          s, GRPC_ERROR_NONE, s->send_message_op,
+          s, absl::OkStatus(), s->send_message_op,
           "op_state_machine scheduling send-message-on-complete case 1");
       s->send_message_op = nullptr;
     }
@@ -647,16 +627,15 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     if (*destfilled || s->trailing_md_sent) {
       // The buffer is already in use; that's an error!
       INPROC_LOG(GPR_INFO, "Extra trailing metadata %p", s);
-      new_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Extra trailing metadata");
-      fail_helper_locked(s, GRPC_ERROR_REF(new_err));
+      new_err = GRPC_ERROR_CREATE("Extra trailing metadata");
+      fail_helper_locked(s, new_err);
       goto done;
     } else {
       if (!other || !other->closed) {
-        (void)fill_in_metadata(
-            s,
-            s->send_trailing_md_op->payload->send_trailing_metadata
-                .send_trailing_metadata,
-            0, dest, nullptr, destfilled);
+        fill_in_metadata(s,
+                         s->send_trailing_md_op->payload->send_trailing_metadata
+                             .send_trailing_metadata,
+                         dest, destfilled);
       }
       s->trailing_md_sent = true;
       if (s->send_trailing_md_op->payload->send_trailing_metadata.sent) {
@@ -669,43 +648,40 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
             DEBUG_LOCATION,
             s->recv_trailing_md_op->payload->recv_trailing_metadata
                 .recv_trailing_metadata_ready,
-            GRPC_ERROR_NONE);
+            absl::OkStatus());
         INPROC_LOG(GPR_INFO,
                    "op_state_machine %p scheduling trailing-md-on-complete", s);
         grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                 s->recv_trailing_md_op->on_complete,
-                                GRPC_ERROR_NONE);
+                                absl::OkStatus());
         s->recv_trailing_md_op = nullptr;
         needs_close = true;
       }
     }
-    maybe_process_ops_locked(other, GRPC_ERROR_NONE);
+    maybe_process_ops_locked(other, absl::OkStatus());
     complete_if_batch_end_locked(
-        s, GRPC_ERROR_NONE, s->send_trailing_md_op,
+        s, absl::OkStatus(), s->send_trailing_md_op,
         "op_state_machine scheduling send-trailing-metadata-on-complete");
     s->send_trailing_md_op = nullptr;
   }
   if (s->recv_initial_md_op) {
     if (s->initial_md_recvd) {
-      new_err =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Already recvd initial md");
+      new_err = GRPC_ERROR_CREATE("Already recvd initial md");
       INPROC_LOG(
           GPR_INFO,
           "op_state_machine %p scheduling on_complete errors for already "
           "recvd initial md %s",
-          s, grpc_error_std_string(new_err).c_str());
-      fail_helper_locked(s, GRPC_ERROR_REF(new_err));
+          s, grpc_core::StatusToString(new_err).c_str());
+      fail_helper_locked(s, new_err);
       goto done;
     }
 
     if (s->to_read_initial_md_filled) {
       s->initial_md_recvd = true;
-      fill_in_metadata(
-          s, &s->to_read_initial_md, s->to_read_initial_md_flags,
-          s->recv_initial_md_op->payload->recv_initial_metadata
-              .recv_initial_metadata,
-          s->recv_initial_md_op->payload->recv_initial_metadata.recv_flags,
-          nullptr);
+      fill_in_metadata(s, &s->to_read_initial_md,
+                       s->recv_initial_md_op->payload->recv_initial_metadata
+                           .recv_initial_metadata,
+                       nullptr);
       if (s->deadline != grpc_core::Timestamp::InfFuture()) {
         s->recv_initial_md_op->payload->recv_initial_metadata
             .recv_initial_metadata->Set(grpc_core::GrpcTimeoutMetadata(),
@@ -723,9 +699,9 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
           DEBUG_LOCATION,
           s->recv_initial_md_op->payload->recv_initial_metadata
               .recv_initial_metadata_ready,
-          GRPC_ERROR_NONE);
+          absl::OkStatus());
       complete_if_batch_end_locked(
-          s, GRPC_ERROR_NONE, s->recv_initial_md_op,
+          s, absl::OkStatus(), s->recv_initial_md_op,
           "op_state_machine scheduling recv-initial-metadata-on-complete");
       s->recv_initial_md_op = nullptr;
     }
@@ -733,7 +709,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   if (s->recv_message_op) {
     if (other && other->send_message_op) {
       message_transfer_locked(other, s);
-      maybe_process_ops_locked(other, GRPC_ERROR_NONE);
+      maybe_process_ops_locked(other, absl::OkStatus());
     }
   }
   if (s->to_read_trailing_md_filled) {
@@ -747,26 +723,25 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
         s->to_read_trailing_md_filled = false;
         s->trailing_md_recvd_implicit_only = false;
       } else {
-        new_err =
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Already recvd trailing md");
+        new_err = GRPC_ERROR_CREATE("Already recvd trailing md");
         INPROC_LOG(
             GPR_INFO,
             "op_state_machine %p scheduling on_complete errors for already "
             "recvd trailing md %s",
-            s, grpc_error_std_string(new_err).c_str());
-        fail_helper_locked(s, GRPC_ERROR_REF(new_err));
+            s, grpc_core::StatusToString(new_err).c_str());
+        fail_helper_locked(s, new_err);
         goto done;
       }
     }
     if (s->recv_message_op != nullptr) {
       // This message needs to be wrapped up because it will never be
       // satisfied
-      *s->recv_message_op->payload->recv_message.recv_message = nullptr;
+      s->recv_message_op->payload->recv_message.recv_message->reset();
       INPROC_LOG(GPR_INFO, "op_state_machine %p scheduling message-ready", s);
       grpc_core::ExecCtx::Run(
           DEBUG_LOCATION,
           s->recv_message_op->payload->recv_message.recv_message_ready,
-          GRPC_ERROR_NONE);
+          absl::OkStatus());
       complete_if_batch_end_locked(
           s, new_err, s->recv_message_op,
           "op_state_machine scheduling recv-message-on-complete");
@@ -775,7 +750,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     if ((s->trailing_md_sent || s->t->is_client) && s->send_message_op) {
       // Nothing further will try to receive from this stream, so finish off
       // any outstanding send_message op
-      s->send_message_op->payload->send_message.send_message.reset();
+      ResetSendMessage(s->send_message_op);
       s->send_message_op->payload->send_message.stream_write_closed = true;
       complete_if_batch_end_locked(
           s, new_err, s->send_message_op,
@@ -785,27 +760,28 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     if (s->recv_trailing_md_op != nullptr) {
       // We wanted trailing metadata and we got it
       s->trailing_md_recvd = true;
-      fill_in_metadata(s, &s->to_read_trailing_md, 0,
+      fill_in_metadata(s, &s->to_read_trailing_md,
                        s->recv_trailing_md_op->payload->recv_trailing_metadata
                            .recv_trailing_metadata,
-                       nullptr, nullptr);
+                       nullptr);
       s->to_read_trailing_md.Clear();
       s->to_read_trailing_md_filled = false;
 
       // We should schedule the recv_trailing_md_op completion if
       // 1. this stream is the client-side
       // 2. this stream is the server-side AND has already sent its trailing md
-      //    (If the server hasn't already sent its trailing md, it doesn't have
+      //    (If the server hasn't already sent its trailing md, it doesn't
+      //    have
       //     a final status, so don't mark this op complete)
       if (s->t->is_client || s->trailing_md_sent) {
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             s->recv_trailing_md_op->payload->recv_trailing_metadata
                 .recv_trailing_metadata_ready,
-            GRPC_ERROR_NONE);
+            absl::OkStatus());
         grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                 s->recv_trailing_md_op->on_complete,
-                                GRPC_ERROR_NONE);
+                                absl::OkStatus());
         s->recv_trailing_md_op = nullptr;
         needs_close = s->trailing_md_sent;
       }
@@ -821,12 +797,12 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     // because we have already sent status and the RPC is over as far as we
     // are concerned.
     INPROC_LOG(GPR_INFO, "op_state_machine %p scheduling trailing-md-ready %s",
-               s, grpc_error_std_string(new_err).c_str());
+               s, grpc_core::StatusToString(new_err).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_trailing_md_op->payload->recv_trailing_metadata
             .recv_trailing_metadata_ready,
-        GRPC_ERROR_REF(new_err));
+        new_err);
     complete_if_batch_end_locked(
         s, new_err, s->recv_trailing_md_op,
         "op_state_machine scheduling recv-trailing-md-on-complete");
@@ -840,11 +816,11 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
     // No further message will come on this stream, so finish off the
     // recv_message_op
     INPROC_LOG(GPR_INFO, "op_state_machine %p scheduling message-ready", s);
-    *s->recv_message_op->payload->recv_message.recv_message = nullptr;
+    s->recv_message_op->payload->recv_message.recv_message->reset();
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_message_op->payload->recv_message.recv_message_ready,
-        GRPC_ERROR_NONE);
+        absl::OkStatus());
     complete_if_batch_end_locked(
         s, new_err, s->recv_message_op,
         "op_state_machine scheduling recv-message-on-complete");
@@ -853,7 +829,7 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   if (s->trailing_md_recvd && s->send_message_op && s->t->is_client) {
     // Nothing further will try to receive from this stream, so finish off
     // any outstanding send_message op
-    s->send_message_op->payload->send_message.send_message.reset();
+    ResetSendMessage(s->send_message_op);
     complete_if_batch_end_locked(
         s, new_err, s->send_message_op,
         "op_state_machine scheduling send-message-on-complete case 3");
@@ -874,16 +850,15 @@ done:
     close_other_side_locked(s, "op_state_machine");
     close_stream_locked(s);
   }
-  GRPC_ERROR_UNREF(new_err);
 }
 
 bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
   bool ret = false;  // was the cancel accepted
   INPROC_LOG(GPR_INFO, "cancel_stream %p with %s", s,
-             grpc_error_std_string(error).c_str());
-  if (s->cancel_self_error == GRPC_ERROR_NONE) {
+             grpc_core::StatusToString(error).c_str());
+  if (s->cancel_self_error.ok()) {
     ret = true;
-    s->cancel_self_error = GRPC_ERROR_REF(error);
+    s->cancel_self_error = error;
     // Catch current value of other before it gets closed off
     inproc_stream* other = s->other_side;
     maybe_process_ops_locked(s, s->cancel_self_error);
@@ -898,15 +873,15 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
                                     : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
                                           : &other->to_read_trailing_md_filled;
-    (void)fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
+    fill_in_metadata(s, &cancel_md, dest, destfilled);
 
     if (other != nullptr) {
-      if (other->cancel_other_error == GRPC_ERROR_NONE) {
-        other->cancel_other_error = GRPC_ERROR_REF(s->cancel_self_error);
+      if (other->cancel_other_error.ok()) {
+        other->cancel_other_error = s->cancel_self_error;
       }
       maybe_process_ops_locked(other, other->cancel_other_error);
-    } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
-      s->write_buffer_cancel_error = GRPC_ERROR_REF(s->cancel_self_error);
+    } else if (s->write_buffer_cancel_error.ok()) {
+      s->write_buffer_cancel_error = s->cancel_self_error;
     }
 
     // if we are a server and already received trailing md but
@@ -917,7 +892,7 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
           DEBUG_LOCATION,
           s->recv_trailing_md_op->payload->recv_trailing_metadata
               .recv_trailing_metadata_ready,
-          GRPC_ERROR_REF(s->cancel_self_error));
+          s->cancel_self_error);
       complete_if_batch_end_locked(
           s, s->cancel_self_error, s->recv_trailing_md_op,
           "cancel_stream scheduling trailing-md-on-complete");
@@ -928,7 +903,6 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
   close_other_side_locked(s, "cancel_stream:other_side");
   close_stream_locked(s);
 
-  GRPC_ERROR_UNREF(error);
   return ret;
 }
 
@@ -951,7 +925,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
                    s->t->is_client, false);
     }
   }
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   grpc_closure* on_complete = op->on_complete;
   // TODO(roth): This is a hack needed because we use data inside of the
   // closure itself to do the barrier calculation (i.e., to ensure that
@@ -968,9 +942,9 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
     // this function is responsible to make sure that that field gets unref'ed
     cancel_stream_locked(s, op->payload->cancel_stream.cancel_error);
     // this op can complete without an error
-  } else if (s->cancel_self_error != GRPC_ERROR_NONE) {
+  } else if (!s->cancel_self_error.ok()) {
     // already self-canceled so still give it an error
-    error = GRPC_ERROR_REF(s->cancel_self_error);
+    error = s->cancel_self_error;
   } else {
     INPROC_LOG(GPR_INFO, "perform_stream_op %p %s%s%s%s%s%s%s", s,
                s->t->is_client ? "client" : "server",
@@ -983,30 +957,25 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
   }
 
   inproc_stream* other = s->other_side;
-  if (error == GRPC_ERROR_NONE &&
-      (op->send_initial_metadata || op->send_trailing_metadata)) {
+  if (error.ok() && (op->send_initial_metadata || op->send_trailing_metadata)) {
     if (s->t->is_closed) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Endpoint already shutdown");
+      error = GRPC_ERROR_CREATE("Endpoint already shutdown");
     }
-    if (error == GRPC_ERROR_NONE && op->send_initial_metadata) {
+    if (error.ok() && op->send_initial_metadata) {
       grpc_metadata_batch* dest = (other == nullptr)
                                       ? &s->write_buffer_initial_md
                                       : &other->to_read_initial_md;
-      uint32_t* destflags = (other == nullptr)
-                                ? &s->write_buffer_initial_md_flags
-                                : &other->to_read_initial_md_flags;
       bool* destfilled = (other == nullptr) ? &s->write_buffer_initial_md_filled
                                             : &other->to_read_initial_md_filled;
       if (*destfilled || s->initial_md_sent) {
         // The buffer is already in use; that's an error!
         INPROC_LOG(GPR_INFO, "Extra initial metadata %p", s);
-        error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Extra initial metadata");
+        error = GRPC_ERROR_CREATE("Extra initial metadata");
       } else {
         if (!s->other_side_closed) {
-          (void)fill_in_metadata(
-              s, op->payload->send_initial_metadata.send_initial_metadata,
-              op->payload->send_initial_metadata.send_initial_metadata_flags,
-              dest, destflags, destfilled);
+          fill_in_metadata(
+              s, op->payload->send_initial_metadata.send_initial_metadata, dest,
+              destfilled);
         }
         if (s->t->is_client) {
           grpc_core::Timestamp* dl =
@@ -1022,10 +991,9 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
     }
   }
 
-  if (error == GRPC_ERROR_NONE &&
-      (op->send_message || op->send_trailing_metadata ||
-       op->recv_initial_metadata || op->recv_message ||
-       op->recv_trailing_metadata)) {
+  if (error.ok() && (op->send_message || op->send_trailing_metadata ||
+                     op->recv_initial_metadata || op->recv_message ||
+                     op->recv_trailing_metadata)) {
     // Mark ops that need to be processed by the state machine
     if (op->send_message) {
       s->send_message_op = op;
@@ -1062,11 +1030,11 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       s->ops_needed = true;
     }
   } else {
-    if (error != GRPC_ERROR_NONE) {
-      // Consume any send message that was sent here but that we are not pushing
-      // to the other side
+    if (!error.ok()) {
+      // Consume any send message that was sent here but that we are not
+      // pushing to the other side
       if (op->send_message) {
-        op->payload->send_message.send_message.reset();
+        ResetSendMessage(op);
       }
       // Schedule op's closures that we didn't push to op state machine
       if (op->recv_initial_metadata) {
@@ -1082,42 +1050,41 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
         INPROC_LOG(
             GPR_INFO,
             "perform_stream_op error %p scheduling initial-metadata-ready %s",
-            s, grpc_error_std_string(error).c_str());
+            s, grpc_core::StatusToString(error).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             op->payload->recv_initial_metadata.recv_initial_metadata_ready,
-            GRPC_ERROR_REF(error));
+            error);
       }
       if (op->recv_message) {
         INPROC_LOG(
             GPR_INFO,
             "perform_stream_op error %p scheduling recv message-ready %s", s,
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
         if (op->payload->recv_message.call_failed_before_recv_message !=
             nullptr) {
           *op->payload->recv_message.call_failed_before_recv_message = true;
         }
         grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                 op->payload->recv_message.recv_message_ready,
-                                GRPC_ERROR_REF(error));
+                                error);
       }
       if (op->recv_trailing_metadata) {
-        INPROC_LOG(
-            GPR_INFO,
-            "perform_stream_op error %p scheduling trailing-metadata-ready %s",
-            s, grpc_error_std_string(error).c_str());
+        INPROC_LOG(GPR_INFO,
+                   "perform_stream_op error %p scheduling "
+                   "trailing-metadata-ready %s",
+                   s, grpc_core::StatusToString(error).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             op->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
-            GRPC_ERROR_REF(error));
+            error);
       }
     }
     INPROC_LOG(GPR_INFO, "perform_stream_op %p scheduling on_complete %s", s,
-               grpc_error_std_string(error).c_str());
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_complete, GRPC_ERROR_REF(error));
+               grpc_core::StatusToString(error).c_str());
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_complete, error);
   }
   gpr_mu_unlock(mu);
-  GRPC_ERROR_UNREF(error);
 }
 
 void close_transport_locked(inproc_transport* t) {
@@ -1126,14 +1093,14 @@ void close_transport_locked(inproc_transport* t) {
                             "close transport");
   if (!t->is_closed) {
     t->is_closed = true;
-    /* Also end all streams on this transport */
+    // Also end all streams on this transport
     while (t->stream_list != nullptr) {
       // cancel_stream_locked also adjusts stream list
       cancel_stream_locked(
           t->stream_list,
-          grpc_error_set_int(
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Transport closed"),
-              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
+          grpc_error_set_int(GRPC_ERROR_CREATE("Transport closed"),
+                             grpc_core::StatusIntProperty::kRpcStatus,
+                             GRPC_STATUS_UNAVAILABLE));
     }
   }
 }
@@ -1154,17 +1121,15 @@ void perform_transport_op(grpc_transport* gt, grpc_transport_op* op) {
     t->accept_stream_data = op->set_accept_stream_user_data;
   }
   if (op->on_consumed) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, absl::OkStatus());
   }
 
   bool do_close = false;
-  if (op->goaway_error != GRPC_ERROR_NONE) {
+  if (!op->goaway_error.ok()) {
     do_close = true;
-    GRPC_ERROR_UNREF(op->goaway_error);
   }
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!op->disconnect_with_error.ok()) {
     do_close = true;
-    GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
 
   if (do_close) {
@@ -1183,7 +1148,7 @@ void destroy_stream(grpc_transport* gt, grpc_stream* gs,
   gpr_mu_unlock(&t->mu->mu);
   s->~inproc_stream();
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure,
-                          GRPC_ERROR_NONE);
+                          absl::OkStatus());
 }
 
 void destroy_transport(grpc_transport* gt) {
@@ -1196,9 +1161,9 @@ void destroy_transport(grpc_transport* gt) {
   t->unref();
 }
 
-/*******************************************************************************
- * INTEGRATION GLUE
- */
+//******************************************************************************
+// INTEGRATION GLUE
+//
 
 void set_pollset(grpc_transport* /*gt*/, grpc_stream* /*gs*/,
                  grpc_pollset* /*pollset*/) {
@@ -1220,13 +1185,11 @@ const grpc_transport_vtable inproc_vtable = {
     destroy_stream,        destroy_transport,
     get_endpoint};
 
-/*******************************************************************************
- * Main inproc transport functions
- */
+//******************************************************************************
+// Main inproc transport functions
+//
 void inproc_transports_create(grpc_transport** server_transport,
-                              const grpc_channel_args* /*server_args*/,
-                              grpc_transport** client_transport,
-                              const grpc_channel_args* /*client_args*/) {
+                              grpc_transport** client_transport) {
   INPROC_LOG(GPR_INFO, "inproc_transports_create");
   shared_mu* mu = new (gpr_malloc(sizeof(*mu))) shared_mu();
   inproc_transport* st = new (gpr_malloc(sizeof(*st)))
@@ -1251,45 +1214,38 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   grpc_core::Server* core_server = grpc_core::Server::FromC(server);
   // Remove max_connection_idle and max_connection_age channel arguments since
   // those do not apply to inproc transports.
-  const char* args_to_remove[] = {GRPC_ARG_MAX_CONNECTION_IDLE_MS,
-                                  GRPC_ARG_MAX_CONNECTION_AGE_MS};
-  const grpc_channel_args* server_args = grpc_channel_args_copy_and_remove(
-      core_server->channel_args(), args_to_remove,
-      GPR_ARRAY_SIZE(args_to_remove));
+  grpc_core::ChannelArgs server_args =
+      core_server->channel_args()
+          .Remove(GRPC_ARG_MAX_CONNECTION_IDLE_MS)
+          .Remove(GRPC_ARG_MAX_CONNECTION_AGE_MS);
+
   // Add a default authority channel argument for the client
-  grpc_arg default_authority_arg;
-  default_authority_arg.type = GRPC_ARG_STRING;
-  default_authority_arg.key = const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY);
-  default_authority_arg.value.string = const_cast<char*>("inproc.authority");
-  args = grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
-  const grpc_channel_args* client_args = grpc_core::CoreConfiguration::Get()
-                                             .channel_args_preconditioning()
-                                             .PreconditionChannelArgs(args)
-                                             .ToC();
-  grpc_channel_args_destroy(args);
+  grpc_core::ChannelArgs client_args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(args)
+          .Set(GRPC_ARG_DEFAULT_AUTHORITY, "inproc.authority");
   grpc_transport* server_transport;
   grpc_transport* client_transport;
-  inproc_transports_create(&server_transport, server_args, &client_transport,
-                           client_args);
+  inproc_transports_create(&server_transport, &client_transport);
 
   // TODO(ncteisen): design and support channelz GetSocket for inproc.
   grpc_error_handle error = core_server->SetupTransport(
       server_transport, nullptr, server_args, nullptr);
   grpc_channel* channel = nullptr;
-  if (error == GRPC_ERROR_NONE) {
+  if (error.ok()) {
     auto new_channel = grpc_core::Channel::Create(
-        "inproc", grpc_core::ChannelArgs::FromC(client_args),
-        GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
+        "inproc", client_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport);
     if (!new_channel.ok()) {
       GPR_ASSERT(!channel);
       gpr_log(GPR_ERROR, "Failed to create client channel: %s",
-              grpc_error_std_string(error).c_str());
+              grpc_core::StatusToString(error).c_str());
       intptr_t integer;
       grpc_status_code status = GRPC_STATUS_INTERNAL;
-      if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
+      if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
+                             &integer)) {
         status = static_cast<grpc_status_code>(integer);
       }
-      GRPC_ERROR_UNREF(error);
       // client_transport was destroyed when grpc_channel_create_internal saw an
       // error.
       grpc_transport_destroy(server_transport);
@@ -1301,24 +1257,18 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   } else {
     GPR_ASSERT(!channel);
     gpr_log(GPR_ERROR, "Failed to create server channel: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;
-    if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
+    if (grpc_error_get_int(error, grpc_core::StatusIntProperty::kRpcStatus,
+                           &integer)) {
       status = static_cast<grpc_status_code>(integer);
     }
-    GRPC_ERROR_UNREF(error);
     grpc_transport_destroy(client_transport);
     grpc_transport_destroy(server_transport);
     channel = grpc_lame_client_channel_create(
         nullptr, status, "Failed to create server channel");
   }
 
-  // Free up created channel args
-  grpc_channel_args_destroy(server_args);
-  grpc_channel_args_destroy(client_args);
-
-  // Now finish scheduled operations
-
   return channel;
 }