grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -19,7 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/security/credentials/credentials.h"
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 

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

@@ -20,14 +20,13 @@
 
 #include "src/core/lib/http/parser.h"
 
-#include <stdbool.h>
 #include <string.h>
 
+#include <algorithm>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/useful.h"
-
 grpc_core::TraceFlag grpc_http1_trace(false, "http1");
 
 static char* buf2str(void* buffer, size_t length) {
@@ -236,7 +235,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   (*hdrs)[(*hdr_count)++] = hdr;
 
 done:
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_free(hdr.key);
     gpr_free(hdr.value);
   }
@@ -249,7 +248,7 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
       err = handle_first_line(parser);
-      if (err != GRPC_ERROR_NONE) return err;
+      if (!GRPC_ERROR_IS_NONE(err)) return err;
       parser->state = GRPC_HTTP_HEADERS;
       break;
     case GRPC_HTTP_HEADERS:
@@ -264,7 +263,7 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
         break;
       } else {
         err = add_header(parser);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
       }
@@ -449,7 +448,7 @@ grpc_error_handle grpc_http_parser_parse(grpc_http_parser* parser,
     bool found_body_start = false;
     grpc_error_handle err =
         addbyte(parser, GRPC_SLICE_START_PTR(slice)[i], &found_body_start);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     if (found_body_start && start_of_body != nullptr) *start_of_body = i + 1;
   }
   return GRPC_ERROR_NONE;

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

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <grpc/slice.h>
 
 #include "src/core/lib/debug/trace.h"

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

@@ -38,11 +38,7 @@ constexpr intptr_t kErrorBit = 1;
 
 grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
-#else
-    return reinterpret_cast<grpc_error_handle>(cancel_state & ~kErrorBit);
-#endif
   }
   return GRPC_ERROR_NONE;
 }
@@ -60,12 +56,7 @@ CallCombiner::CallCombiner() {
 
 CallCombiner::~CallCombiner() {
   if (cancel_state_ & kErrorBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     internal::StatusFreeHeapPtr(cancel_state_ & ~kErrorBit);
-#else
-    GRPC_ERROR_UNREF(reinterpret_cast<grpc_error_handle>(
-        cancel_state_ & ~static_cast<gpr_atm>(kErrorBit)));
-#endif
   }
 }
 
@@ -150,11 +141,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
       gpr_log(GPR_INFO, "  QUEUING");
     }
     // Queue was not empty, so add closure to queue.
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     closure->error_data.error = internal::StatusAllocHeapPtr(error);
-#else
-    closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
     queue_.Push(
         reinterpret_cast<MultiProducerSingleConsumerQueue::Node*>(closure));
   }
@@ -189,13 +176,8 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
         }
         continue;
       }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       grpc_error_handle error =
           internal::StatusMoveFromHeapPtr(closure->error_data.error);
-#else
-      grpc_error_handle error =
-          reinterpret_cast<grpc_error_handle>(closure->error_data.error);
-#endif
       closure->error_data.error = 0;
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%p error=%s",
@@ -217,7 +199,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
-    if (original_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(original_error)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO,
                 "call_combiner=%p: scheduling notify_on_cancel callback=%p "
@@ -254,21 +236,13 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 
 void CallCombiner::Cancel(grpc_error_handle error) {
   GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
   gpr_atm new_state = kErrorBit | status_ptr;
-#else
-  gpr_atm new_state = kErrorBit | reinterpret_cast<gpr_atm>(error);
-#endif
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
-    if (original_error != GRPC_ERROR_NONE) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    if (!GRPC_ERROR_IS_NONE(original_error)) {
       internal::StatusFreeHeapPtr(status_ptr);
-#else
-      GRPC_ERROR_UNREF(error);
-#endif
       break;
     }
     if (gpr_atm_full_cas(&cancel_state_, original_state, new_state)) {

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

@@ -199,11 +199,7 @@ inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
     GRPC_ERROR_UNREF(error);
     return false;
   }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   closure->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
-#else
-  closure->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
   return grpc_closure_list_append(closure_list, closure);
 }
 
@@ -212,13 +208,8 @@ inline void grpc_closure_list_fail_all(grpc_closure_list* list,
                                        grpc_error_handle forced_failure) {
   for (grpc_closure* c = list->head; c != nullptr; c = c->next_data.next) {
     if (c->error_data.error == 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       c->error_data.error =
           grpc_core::internal::StatusAllocHeapPtr(forced_failure);
-#else
-      c->error_data.error =
-          reinterpret_cast<intptr_t>(GRPC_ERROR_REF(forced_failure));
-#endif
     }
   }
   GRPC_ERROR_UNREF(forced_failure);

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

@@ -149,11 +149,7 @@ static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
   }
   GPR_ASSERT(last & STATE_UNORPHANED);  // ensure lock has not been destroyed
   assert(cl->cb);
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   cl->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
-#else
-  cl->error_data.error = reinterpret_cast<intptr_t>(error);
-#endif
   lock->queue.Push(cl->next_data.mpscq_node.get());
 }
 
@@ -228,18 +224,10 @@ bool grpc_combiner_continue_exec_ctx() {
 #ifndef NDEBUG
     cl->scheduled = false;
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     grpc_error_handle cl_err =
         grpc_core::internal::StatusMoveFromHeapPtr(cl->error_data.error);
     cl->error_data.error = 0;
     cl->cb(cl->cb_arg, std::move(cl_err));
-#else
-    grpc_error_handle cl_err =
-        reinterpret_cast<grpc_error_handle>(cl->error_data.error);
-    cl->error_data.error = 0;
-    cl->cb(cl->cb_arg, cl_err);
-    GRPC_ERROR_UNREF(cl_err);
-#endif
   } else {
     grpc_closure* c = lock->final_list.head;
     GPR_ASSERT(c != nullptr);
@@ -252,18 +240,10 @@ bool grpc_combiner_continue_exec_ctx() {
 #ifndef NDEBUG
       c->scheduled = false;
 #endif
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       grpc_error_handle error =
           grpc_core::internal::StatusMoveFromHeapPtr(c->error_data.error);
       c->error_data.error = 0;
       c->cb(c->cb_arg, std::move(error));
-#else
-      grpc_error_handle error =
-          reinterpret_cast<grpc_error_handle>(c->error_data.error);
-      c->error_data.error = 0;
-      c->cb(c->cb_arg, error);
-      GRPC_ERROR_UNREF(error);
-#endif
       c = next;
     }
   }

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

@@ -56,7 +56,7 @@ struct grpc_endpoint_vtable {
    Callback success indicates that the endpoint can accept more reads, failure
    indicates the endpoint is closed.
    Valid slices may be placed into \a slices even when the callback is
-   invoked with error != GRPC_ERROR_NONE. */
+   invoked with !GRPC_ERROR_IS_NONE(error). */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
                         grpc_closure* cb, bool urgent, int min_progress_size);
 

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

@@ -147,7 +147,7 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 static void ReadAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->read_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
     CallReadCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "read");
@@ -189,7 +189,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
 static void WriteAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->write_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
     CallWriteCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "write");

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

@@ -63,7 +63,8 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
                                           .channel_args_preconditioning()
                                           .PreconditionChannelArgs(args)
-                                          .ToC();
+                                          .ToC()
+                                          .release();
   p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
                              new_args, "socketpair-server");
   final_name = absl::StrCat(name, ":server");