grpc 1.10.0 → 1.11.0.pre2

data/src/core/ext/filters/http/client_authority_filter.h

@@ -0,0 +1,34 @@
+/*
+ *
+ * Copyright 2018 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_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/impl/codegen/compression_types.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+
+/// Filter responsible for setting the authority header, if not already set. It
+/// uses the value of the GRPC_ARG_DEFAULT_AUTHORITY channel arg if the initial
+/// metadata doesn't already contain an authority value.
+
+extern const grpc_channel_filter grpc_client_authority_filter;
+
+#endif /* GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H */

data/src/core/ext/filters/http/http_filters_plugin.cc

@@ -16,6 +16,8 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include <string.h>
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"

data/src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -16,6 +16,8 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include <assert.h>
 #include <string.h>
 
@@ -30,6 +32,7 @@
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -60,7 +63,8 @@ struct call_data {
   grpc_closure start_send_message_batch_in_call_combiner;
   grpc_transport_stream_op_batch* send_message_batch;
   grpc_slice_buffer slices; /**< Buffers up input slices to be compressed */
-  grpc_slice_buffer_stream replacement_stream;
+  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream>
+      replacement_stream;
   grpc_closure* original_send_message_on_complete;
   grpc_closure send_message_on_complete;
   grpc_closure on_send_message_next_done;
@@ -218,7 +222,7 @@ static void finish_send_message(grpc_call_element* elem) {
   grpc_slice_buffer tmp;
   grpc_slice_buffer_init(&tmp);
   uint32_t send_flags =
-      calld->send_message_batch->payload->send_message.send_message->flags;
+      calld->send_message_batch->payload->send_message.send_message->flags();
   bool did_compress = grpc_msg_compress(calld->message_compression_algorithm,
                                         &calld->slices, &tmp);
   if (did_compress) {
@@ -251,12 +255,9 @@ static void finish_send_message(grpc_call_element* elem) {
   grpc_slice_buffer_destroy_internal(&tmp);
   // Swap out the original byte stream with our new one and send the
   // batch down.
-  grpc_byte_stream_destroy(
-      calld->send_message_batch->payload->send_message.send_message);
-  grpc_slice_buffer_stream_init(&calld->replacement_stream, &calld->slices,
-                                send_flags);
-  calld->send_message_batch->payload->send_message.send_message =
-      &calld->replacement_stream.base;
+  calld->replacement_stream.Init(&calld->slices, send_flags);
+  calld->send_message_batch->payload->send_message.send_message.reset(
+      calld->replacement_stream.get());
   calld->original_send_message_on_complete =
       calld->send_message_batch->on_complete;
   calld->send_message_batch->on_complete = &calld->send_message_on_complete;
@@ -276,9 +277,9 @@ static void fail_send_message_batch_in_call_combiner(void* arg,
 // Pulls a slice from the send_message byte stream and adds it to calld->slices.
 static grpc_error* pull_slice_from_send_message(call_data* calld) {
   grpc_slice incoming_slice;
-  grpc_error* error = grpc_byte_stream_pull(
-      calld->send_message_batch->payload->send_message.send_message,
-      &incoming_slice);
+  grpc_error* error =
+      calld->send_message_batch->payload->send_message.send_message->Pull(
+          &incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     grpc_slice_buffer_add(&calld->slices, incoming_slice);
   }
@@ -287,12 +288,11 @@ static grpc_error* pull_slice_from_send_message(call_data* calld) {
 
 // Reads as many slices as possible from the send_message byte stream.
 // If all data has been read, invokes finish_send_message().  Otherwise,
-// an async call to grpc_byte_stream_next() has been started, which will
+// an async call to ByteStream::Next() has been started, which will
 // eventually result in calling on_send_message_next_done().
 static void continue_reading_send_message(grpc_call_element* elem) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  while (grpc_byte_stream_next(
-      calld->send_message_batch->payload->send_message.send_message,
+  while (calld->send_message_batch->payload->send_message.send_message->Next(
       ~static_cast<size_t>(0), &calld->on_send_message_next_done)) {
     grpc_error* error = pull_slice_from_send_message(calld);
     if (error != GRPC_ERROR_NONE) {
@@ -301,15 +301,15 @@ static void continue_reading_send_message(grpc_call_element* elem) {
       GRPC_ERROR_UNREF(error);
       return;
     }
-    if (calld->slices.length ==
-        calld->send_message_batch->payload->send_message.send_message->length) {
+    if (calld->slices.length == calld->send_message_batch->payload->send_message
+                                    .send_message->length()) {
       finish_send_message(elem);
       break;
     }
   }
 }
 
-// Async callback for grpc_byte_stream_next().
+// Async callback for ByteStream::Next().
 static void on_send_message_next_done(void* arg, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
@@ -326,7 +326,7 @@ static void on_send_message_next_done(void* arg, grpc_error* error) {
     return;
   }
   if (calld->slices.length ==
-      calld->send_message_batch->payload->send_message.send_message->length) {
+      calld->send_message_batch->payload->send_message.send_message->length()) {
     finish_send_message(elem);
   } else {
     continue_reading_send_message(elem);
@@ -338,7 +338,8 @@ static void start_send_message_batch(void* arg, grpc_error* unused) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (skip_compression(
           elem,
-          calld->send_message_batch->payload->send_message.send_message->flags,
+          calld->send_message_batch->payload->send_message.send_message
+              ->flags(),
           calld->send_initial_metadata_state == HAS_COMPRESSION_ALGORITHM)) {
     send_message_batch_continue(elem);
   } else {
@@ -363,9 +364,7 @@ static void compress_start_transport_stream_op_batch(
                                 grpc_schedule_on_exec_ctx),
             GRPC_ERROR_REF(calld->cancel_error), "failing send_message op");
       } else {
-        grpc_byte_stream_shutdown(
-
-            calld->send_message_batch->payload->send_message.send_message,
+        calld->send_message_batch->payload->send_message.send_message->Shutdown(
             GRPC_ERROR_REF(calld->cancel_error));
       }
     }

data/src/core/ext/filters/http/message_compress/message_compress_filter.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_MESSAGE_COMPRESS_FILTER_H
 #define GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_MESSAGE_COMPRESS_FILTER_H
 
+#include <grpc/support/port_platform.h>
+
 #include <grpc/impl/codegen/compression_types.h>
 
 #include "src/core/lib/channel/channel_stack.h"

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -16,11 +16,14 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <string.h>
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/slice/percent_encoding.h"
@@ -51,8 +54,8 @@ struct call_data {
    */
   grpc_closure* recv_message_ready;
   grpc_closure* on_complete;
-  grpc_byte_stream** pp_recv_message;
-  grpc_slice_buffer_stream read_stream;
+  grpc_core::OrphanablePtr<grpc_core::ByteStream>* pp_recv_message;
+  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> read_stream;
 
   /** Receive closures are chained: we inject this closure as the on_done_recv
       up-call on transport_op, and remember to call our on_done_recv member
@@ -230,7 +233,7 @@ static grpc_error* server_filter_incoming_metadata(grpc_call_element* elem,
           grpc_base64_decode_with_len(
               reinterpret_cast<const char*> GRPC_SLICE_START_PTR(query_slice),
               GRPC_SLICE_LENGTH(query_slice), k_url_safe));
-      grpc_slice_buffer_stream_init(&calld->read_stream, &read_slice_buffer, 0);
+      calld->read_stream.Init(&read_slice_buffer, 0);
       grpc_slice_buffer_destroy_internal(&read_slice_buffer);
       calld->seen_path_with_query = true;
       grpc_slice_unref_internal(query_slice);
@@ -279,10 +282,10 @@ static void hs_on_complete(void* user_data, grpc_error* err) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   /* Call recv_message_ready if we got the payload via the path field */
   if (calld->seen_path_with_query && calld->recv_message_ready != nullptr) {
-    *calld->pp_recv_message =
-        calld->payload_bin_delivered
-            ? nullptr
-            : reinterpret_cast<grpc_byte_stream*>(&calld->read_stream);
+    calld->pp_recv_message->reset(
+        calld->payload_bin_delivered ? nullptr
+                                     : reinterpret_cast<grpc_core::ByteStream*>(
+                                           calld->read_stream.get()));
     // Re-enter call combiner for recv_message_ready, since the surface
     // code will release the call combiner for each callback it receives.
     GRPC_CALL_COMBINER_START(calld->call_combiner, calld->recv_message_ready,
@@ -403,7 +406,7 @@ static void destroy_call_elem(grpc_call_element* elem,
                               grpc_closure* ignored) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->seen_path_with_query && !calld->payload_bin_delivered) {
-    grpc_byte_stream_destroy(&calld->read_stream.base);
+    calld->read_stream->Orphan();
   }
 }
 

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
 #define GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_stack.h"
 
 /* Processes metadata on the client side for HTTP2 transports */

data/src/core/ext/filters/load_reporting/server_load_reporting_filter.cc

@@ -16,6 +16,8 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include <string.h>
 
 #include <grpc/load_reporting.h>

data/src/core/ext/filters/load_reporting/server_load_reporting_filter.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_FILTER_H
 #define GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_FILTER_H
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/filters/load_reporting/server_load_reporting_plugin.h"
 #include "src/core/lib/channel/channel_stack.h"
 

data/src/core/ext/filters/load_reporting/server_load_reporting_plugin.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_PLUGIN_H
 #define GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_PLUGIN_H
 
+#include <grpc/support/port_platform.h>
+
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/channel/channel_stack.h"

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -16,6 +16,8 @@
  *
  */
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/filters/max_age/max_age_filter.h"
 
 #include <limits.h>

data/src/core/ext/filters/max_age/max_age_filter.h

@@ -17,6 +17,8 @@
 #ifndef GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
 #define GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_stack.h"
 
 extern const grpc_channel_filter grpc_max_age_filter;

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 
 #include <limits.h>
@@ -27,6 +29,8 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/service_config.h"
 
@@ -35,27 +39,29 @@ typedef struct {
   int max_recv_size;
 } message_size_limits;
 
-typedef struct {
-  gpr_refcount refs;
-  message_size_limits limits;
-} refcounted_message_size_limits;
+namespace grpc_core {
+namespace {
 
-static void* refcounted_message_size_limits_ref(void* value) {
-  refcounted_message_size_limits* limits =
-      static_cast<refcounted_message_size_limits*>(value);
-  gpr_ref(&limits->refs);
-  return value;
-}
+class MessageSizeLimits : public RefCounted<MessageSizeLimits> {
+ public:
+  static RefCountedPtr<MessageSizeLimits> CreateFromJson(const grpc_json* json);
+
+  const message_size_limits& limits() const { return limits_; }
+
+ private:
+  // So New() can call our private ctor.
+  template <typename T, typename... Args>
+  friend T* grpc_core::New(Args&&... args);
 
-static void refcounted_message_size_limits_unref(void* value) {
-  refcounted_message_size_limits* limits =
-      static_cast<refcounted_message_size_limits*>(value);
-  if (gpr_unref(&limits->refs)) {
-    gpr_free(value);
+  MessageSizeLimits(int max_send_size, int max_recv_size) {
+    limits_.max_send_size = max_send_size;
+    limits_.max_recv_size = max_recv_size;
   }
-}
 
-static void* refcounted_message_size_limits_create_from_json(
+  message_size_limits limits_;
+};
+
+RefCountedPtr<MessageSizeLimits> MessageSizeLimits::CreateFromJson(
     const grpc_json* json) {
   int max_request_message_bytes = -1;
   int max_response_message_bytes = -1;
@@ -77,16 +83,15 @@ static void* refcounted_message_size_limits_create_from_json(
       if (max_response_message_bytes == -1) return nullptr;
     }
   }
-  refcounted_message_size_limits* value =
-      static_cast<refcounted_message_size_limits*>(
-          gpr_malloc(sizeof(refcounted_message_size_limits)));
-  gpr_ref_init(&value->refs, 1);
-  value->limits.max_send_size = max_request_message_bytes;
-  value->limits.max_recv_size = max_response_message_bytes;
-  return value;
+  return MakeRefCounted<MessageSizeLimits>(max_request_message_bytes,
+                                           max_response_message_bytes);
 }
 
+}  // namespace
+}  // namespace grpc_core
+
 namespace {
+
 struct call_data {
   grpc_call_combiner* call_combiner;
   message_size_limits limits;
@@ -95,7 +100,7 @@ struct call_data {
   // call our next_recv_message_ready member after handling it.
   grpc_closure recv_message_ready;
   // Used by recv_message_ready.
-  grpc_byte_stream** recv_message;
+  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
   // Original recv_message_ready callback, invoked after our own.
   grpc_closure* next_recv_message_ready;
 };
@@ -103,8 +108,11 @@ struct call_data {
 struct channel_data {
   message_size_limits limits;
   // Maps path names to refcounted_message_size_limits structs.
-  grpc_slice_hash_table* method_limit_table;
+  grpc_core::RefCountedPtr<grpc_core::SliceHashTable<
+      grpc_core::RefCountedPtr<grpc_core::MessageSizeLimits>>>
+      method_limit_table;
 };
+
 }  // namespace
 
 // Callback invoked when we receive a message.  Here we check the max
@@ -113,12 +121,12 @@ static void recv_message_ready(void* user_data, grpc_error* error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (*calld->recv_message != nullptr && calld->limits.max_recv_size >= 0 &&
-      (*calld->recv_message)->length >
+      (*calld->recv_message)->length() >
           static_cast<size_t>(calld->limits.max_recv_size)) {
     char* message_string;
     gpr_asprintf(&message_string,
                  "Received message larger than max (%u vs. %d)",
-                 (*calld->recv_message)->length, calld->limits.max_recv_size);
+                 (*calld->recv_message)->length(), calld->limits.max_recv_size);
     grpc_error* new_error = grpc_error_set_int(
         GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
@@ -142,11 +150,11 @@ static void start_transport_stream_op_batch(
   call_data* calld = static_cast<call_data*>(elem->call_data);
   // Check max send message size.
   if (op->send_message && calld->limits.max_send_size >= 0 &&
-      op->payload->send_message.send_message->length >
+      op->payload->send_message.send_message->length() >
           static_cast<size_t>(calld->limits.max_send_size)) {
     char* message_string;
     gpr_asprintf(&message_string, "Sent message larger than max (%u vs. %d)",
-                 op->payload->send_message.send_message->length,
+                 op->payload->send_message.send_message->length(),
                  calld->limits.max_send_size);
     grpc_transport_stream_op_batch_finish_with_failure(
         op,
@@ -183,20 +191,19 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
   // size to the receive limit.
   calld->limits = chand->limits;
   if (chand->method_limit_table != nullptr) {
-    refcounted_message_size_limits* limits =
-        static_cast<refcounted_message_size_limits*>(
-            grpc_method_config_table_get(chand->method_limit_table,
-                                         args->path));
+    grpc_core::RefCountedPtr<grpc_core::MessageSizeLimits> limits =
+        grpc_core::ServiceConfig::MethodConfigTableLookup(
+            *chand->method_limit_table, args->path);
     if (limits != nullptr) {
-      if (limits->limits.max_send_size >= 0 &&
-          (limits->limits.max_send_size < calld->limits.max_send_size ||
+      if (limits->limits().max_send_size >= 0 &&
+          (limits->limits().max_send_size < calld->limits.max_send_size ||
            calld->limits.max_send_size < 0)) {
-        calld->limits.max_send_size = limits->limits.max_send_size;
+        calld->limits.max_send_size = limits->limits().max_send_size;
       }
-      if (limits->limits.max_recv_size >= 0 &&
-          (limits->limits.max_recv_size < calld->limits.max_recv_size ||
+      if (limits->limits().max_recv_size >= 0 &&
+          (limits->limits().max_recv_size < calld->limits.max_recv_size ||
            calld->limits.max_recv_size < 0)) {
-        calld->limits.max_recv_size = limits->limits.max_recv_size;
+        calld->limits.max_recv_size = limits->limits().max_recv_size;
       }
     }
   }
@@ -251,15 +258,11 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
       grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG);
   const char* service_config_str = grpc_channel_arg_get_string(channel_arg);
   if (service_config_str != nullptr) {
-    grpc_service_config* service_config =
-        grpc_service_config_create(service_config_str);
+    grpc_core::UniquePtr<grpc_core::ServiceConfig> service_config =
+        grpc_core::ServiceConfig::Create(service_config_str);
     if (service_config != nullptr) {
-      chand->method_limit_table =
-          grpc_service_config_create_method_config_table(
-              service_config, refcounted_message_size_limits_create_from_json,
-              refcounted_message_size_limits_ref,
-              refcounted_message_size_limits_unref);
-      grpc_service_config_destroy(service_config);
+      chand->method_limit_table = service_config->CreateMethodConfigTable(
+          grpc_core::MessageSizeLimits::CreateFromJson);
     }
   }
   return GRPC_ERROR_NONE;
@@ -268,7 +271,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 // Destructor for channel_data.
 static void destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_slice_hash_table_unref(chand->method_limit_table);
+  chand->method_limit_table.reset();
 }
 
 const grpc_channel_filter grpc_message_size_filter = {