grpc 1.37.1 → 1.38.0.pre1

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

@@ -50,15 +50,15 @@ void grpc_wakeup_fd_global_destroy(void) { wakeup_fd_vtable = nullptr; }
 
 int grpc_has_wakeup_fd(void) { return has_real_wakeup_fd; }
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->init(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->consume(fd_info);
 }
 
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) {
   return wakeup_fd_vtable->wakeup(fd_info);
 }
 

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

@@ -65,9 +65,9 @@ void grpc_enable_cv_wakeup_fds(int enable);
 typedef struct grpc_wakeup_fd grpc_wakeup_fd;
 
 typedef struct grpc_wakeup_fd_vtable {
-  grpc_error* (*init)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*consume)(grpc_wakeup_fd* fd_info);
-  grpc_error* (*wakeup)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*init)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*consume)(grpc_wakeup_fd* fd_info);
+  grpc_error_handle (*wakeup)(grpc_wakeup_fd* fd_info);
   void (*destroy)(grpc_wakeup_fd* fd_info);
   /* Must be called before calling any other functions */
   int (*check_availability)(void);
@@ -83,10 +83,12 @@ extern int grpc_allow_pipe_wakeup_fd;
 
 #define GRPC_WAKEUP_FD_GET_READ_FD(fd_info) ((fd_info)->read_fd)
 
-grpc_error* grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
+    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
     GRPC_MUST_USE_RESULT;
-grpc_error* grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info) GRPC_MUST_USE_RESULT;
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
 /* Defined in some specialized implementation's .c file, or by

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

@@ -20,6 +20,8 @@
 
 #include <functional>
 
+#include "absl/synchronization/mutex.h"
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -43,12 +45,26 @@ namespace grpc_core {
 // other callbacks from other threads might also be executed before Run()
 // returns. Since an arbitrary set of callbacks might be executed when Run() is
 // called, generally no locks should be held while calling Run().
-class WorkSerializer {
+class ABSL_LOCKABLE WorkSerializer {
  public:
   WorkSerializer();
 
   ~WorkSerializer();
 
+  // Runs a given callback.
+  //
+  // If you want to use clang thread annotation to make sure that callback is
+  // called by WorkSerializer only, you need to add the annotation to both the
+  // lambda function given to Run and the actual callback function like;
+  //
+  //   void run_callback() {
+  //     work_serializer.Run(
+  //         []() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) {
+  //            callback();
+  //         }, DEBUG_LOCATION);
+  //   }
+  //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
+  //
   // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
   // once we can start using it directly.
   void Run(std::function<void()> callback,

data/src/core/lib/json/json.h

@@ -56,7 +56,7 @@ class Json {
   using Array = std::vector<Json>;
 
   // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(absl::string_view json_str, grpc_error** error);
+  static Json Parse(absl::string_view json_str, grpc_error_handle* error);
 
   Json() = default;
 

data/src/core/lib/json/json_reader.cc

@@ -38,7 +38,7 @@ namespace {
 
 class JsonReader {
  public:
-  static grpc_error* Parse(absl::string_view input, Json* output);
+  static grpc_error_handle Parse(absl::string_view input, Json* output);
 
  private:
   enum class Status {
@@ -117,7 +117,7 @@ class JsonReader {
   bool container_just_begun_ = false;
   uint16_t unicode_char_ = 0;
   uint16_t unicode_high_surrogate_ = 0;
-  std::vector<grpc_error*> errors_;
+  std::vector<grpc_error_handle> errors_;
   bool truncated_errors_ = false;
 
   Json root_value_;
@@ -821,7 +821,7 @@ JsonReader::Status JsonReader::Run() {
   GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
 }
 
-grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
+grpc_error_handle JsonReader::Parse(absl::string_view input, Json* output) {
   JsonReader reader(input);
   Status status = reader.Run();
   if (reader.truncated_errors_) {
@@ -849,7 +849,7 @@ grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
 
 }  // namespace
 
-Json Json::Parse(absl::string_view json_str, grpc_error** error) {
+Json Json::Parse(absl::string_view json_str, grpc_error_handle* error) {
   Json value;
   *error = JsonReader::Parse(json_str, &value);
   return value;

data/src/core/lib/matchers/matchers.cc

@@ -31,7 +31,7 @@ namespace grpc_core {
 absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
                                                     absl::string_view matcher,
                                                     bool case_sensitive) {
-  if (type == Type::SAFE_REGEX) {
+  if (type == Type::kSafeRegex) {
     RE2::Options options;
     options.set_case_sensitive(case_sensitive);
     auto regex_matcher = absl::make_unique<RE2>(std::string(matcher), options);
@@ -51,13 +51,13 @@ StringMatcher::StringMatcher(Type type, absl::string_view matcher,
 
 StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher,
                              bool case_sensitive)
-    : type_(Type::SAFE_REGEX),
+    : type_(Type::kSafeRegex),
       regex_matcher_(std::move(regex_matcher)),
       case_sensitive_(case_sensitive) {}
 
 StringMatcher::StringMatcher(const StringMatcher& other)
     : type_(other.type_), case_sensitive_(other.case_sensitive_) {
-  if (type_ == Type::SAFE_REGEX) {
+  if (type_ == Type::kSafeRegex) {
     RE2::Options options;
     options.set_case_sensitive(other.case_sensitive_);
     regex_matcher_ =
@@ -69,7 +69,7 @@ StringMatcher::StringMatcher(const StringMatcher& other)
 
 StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
   type_ = other.type_;
-  if (type_ == Type::SAFE_REGEX) {
+  if (type_ == Type::kSafeRegex) {
     RE2::Options options;
     options.set_case_sensitive(other.case_sensitive_);
     regex_matcher_ =
@@ -83,7 +83,7 @@ StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
 
 StringMatcher::StringMatcher(StringMatcher&& other) noexcept
     : type_(other.type_), case_sensitive_(other.case_sensitive_) {
-  if (type_ == Type::SAFE_REGEX) {
+  if (type_ == Type::kSafeRegex) {
     regex_matcher_ = std::move(other.regex_matcher_);
   } else {
     string_matcher_ = std::move(other.string_matcher_);
@@ -92,7 +92,7 @@ StringMatcher::StringMatcher(StringMatcher&& other) noexcept
 
 StringMatcher& StringMatcher::operator=(StringMatcher&& other) noexcept {
   type_ = other.type_;
-  if (type_ == Type::SAFE_REGEX) {
+  if (type_ == Type::kSafeRegex) {
     regex_matcher_ = std::move(other.regex_matcher_);
   } else {
     string_matcher_ = std::move(other.string_matcher_);
@@ -105,7 +105,7 @@ bool StringMatcher::operator==(const StringMatcher& other) const {
   if (type_ != other.type_ || case_sensitive_ != other.case_sensitive_) {
     return false;
   }
-  if (type_ == Type::SAFE_REGEX) {
+  if (type_ == Type::kSafeRegex) {
     return regex_matcher_->pattern() == other.regex_matcher_->pattern();
   } else {
     return string_matcher_ == other.string_matcher_;
@@ -114,22 +114,22 @@ bool StringMatcher::operator==(const StringMatcher& other) const {
 
 bool StringMatcher::Match(absl::string_view value) const {
   switch (type_) {
-    case Type::EXACT:
+    case Type::kExact:
       return case_sensitive_ ? value == string_matcher_
                              : absl::EqualsIgnoreCase(value, string_matcher_);
-    case StringMatcher::Type::PREFIX:
+    case StringMatcher::Type::kPrefix:
       return case_sensitive_
                  ? absl::StartsWith(value, string_matcher_)
                  : absl::StartsWithIgnoreCase(value, string_matcher_);
-    case StringMatcher::Type::SUFFIX:
+    case StringMatcher::Type::kSuffix:
       return case_sensitive_ ? absl::EndsWith(value, string_matcher_)
                              : absl::EndsWithIgnoreCase(value, string_matcher_);
-    case StringMatcher::Type::CONTAINS:
+    case StringMatcher::Type::kContains:
       return case_sensitive_
                  ? absl::StrContains(value, string_matcher_)
                  : absl::StrContains(absl::AsciiStrToLower(value),
                                      absl::AsciiStrToLower(string_matcher_));
-    case StringMatcher::Type::SAFE_REGEX:
+    case StringMatcher::Type::kSafeRegex:
       return RE2::FullMatch(std::string(value), *regex_matcher_);
     default:
       return false;
@@ -138,19 +138,19 @@ bool StringMatcher::Match(absl::string_view value) const {
 
 std::string StringMatcher::ToString() const {
   switch (type_) {
-    case Type::EXACT:
+    case Type::kExact:
       return absl::StrFormat("StringMatcher{exact=%s%s}", string_matcher_,
                              case_sensitive_ ? "" : ", case_sensitive=false");
-    case Type::PREFIX:
+    case Type::kPrefix:
       return absl::StrFormat("StringMatcher{prefix=%s%s}", string_matcher_,
                              case_sensitive_ ? "" : ", case_sensitive=false");
-    case Type::SUFFIX:
+    case Type::kSuffix:
       return absl::StrFormat("StringMatcher{suffix=%s%s}", string_matcher_,
                              case_sensitive_ ? "" : ", case_sensitive=false");
-    case Type::CONTAINS:
+    case Type::kContains:
       return absl::StrFormat("StringMatcher{contains=%s%s}", string_matcher_,
                              case_sensitive_ ? "" : ", case_sensitive=false");
-    case Type::SAFE_REGEX:
+    case Type::kSafeRegex:
       return absl::StrFormat("StringMatcher{safe_regex=%s%s}",
                              regex_matcher_->pattern(),
                              case_sensitive_ ? "" : ", case_sensitive=false");
@@ -177,7 +177,7 @@ absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
     }
     return HeaderMatcher(name, type, std::move(string_matcher.value()),
                          invert_match);
-  } else if (type == Type::RANGE) {
+  } else if (type == Type::kRange) {
     if (range_start > range_end) {
       return absl::InvalidArgumentError(
           "Invalid range specifier specified: end cannot be smaller than "
@@ -199,7 +199,7 @@ HeaderMatcher::HeaderMatcher(absl::string_view name, Type type,
 HeaderMatcher::HeaderMatcher(absl::string_view name, int64_t range_start,
                              int64_t range_end, bool invert_match)
     : name_(name),
-      type_(Type::RANGE),
+      type_(Type::kRange),
       range_start_(range_start),
       range_end_(range_end),
       invert_match_(invert_match) {}
@@ -207,7 +207,7 @@ HeaderMatcher::HeaderMatcher(absl::string_view name, int64_t range_start,
 HeaderMatcher::HeaderMatcher(absl::string_view name, bool present_match,
                              bool invert_match)
     : name_(name),
-      type_(Type::PRESENT),
+      type_(Type::kPresent),
       present_match_(present_match),
       invert_match_(invert_match) {}
 
@@ -216,11 +216,11 @@ HeaderMatcher::HeaderMatcher(const HeaderMatcher& other)
       type_(other.type_),
       invert_match_(other.invert_match_) {
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       range_start_ = other.range_start_;
       range_end_ = other.range_end_;
       break;
-    case Type::PRESENT:
+    case Type::kPresent:
       present_match_ = other.present_match_;
       break;
     default:
@@ -233,11 +233,11 @@ HeaderMatcher& HeaderMatcher::operator=(const HeaderMatcher& other) {
   type_ = other.type_;
   invert_match_ = other.invert_match_;
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       range_start_ = other.range_start_;
       range_end_ = other.range_end_;
       break;
-    case Type::PRESENT:
+    case Type::kPresent:
       present_match_ = other.present_match_;
       break;
     default:
@@ -251,11 +251,11 @@ HeaderMatcher::HeaderMatcher(HeaderMatcher&& other) noexcept
       type_(other.type_),
       invert_match_(other.invert_match_) {
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       range_start_ = other.range_start_;
       range_end_ = other.range_end_;
       break;
-    case Type::PRESENT:
+    case Type::kPresent:
       present_match_ = other.present_match_;
       break;
     default:
@@ -268,11 +268,11 @@ HeaderMatcher& HeaderMatcher::operator=(HeaderMatcher&& other) noexcept {
   type_ = other.type_;
   invert_match_ = other.invert_match_;
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       range_start_ = other.range_start_;
       range_end_ = other.range_end_;
       break;
-    case Type::PRESENT:
+    case Type::kPresent:
       present_match_ = other.present_match_;
       break;
     default:
@@ -286,10 +286,10 @@ bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
   if (type_ != other.type_) return false;
   if (invert_match_ != other.invert_match_) return false;
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       return range_start_ == other.range_start_ &&
              range_end_ == other.range_end_;
-    case Type::PRESENT:
+    case Type::kPresent:
       return present_match_ == other.present_match_;
     default:
       return matcher_ == other.matcher_;
@@ -299,12 +299,12 @@ bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
 bool HeaderMatcher::Match(
     const absl::optional<absl::string_view>& value) const {
   bool match;
-  if (type_ == Type::PRESENT) {
+  if (type_ == Type::kPresent) {
     match = value.has_value() == present_match_;
   } else if (!value.has_value()) {
     // All other types fail to match if field is not present.
     match = false;
-  } else if (type_ == Type::RANGE) {
+  } else if (type_ == Type::kRange) {
     int64_t int_value;
     match = absl::SimpleAtoi(value.value(), &int_value) &&
             int_value >= range_start_ && int_value < range_end_;
@@ -316,19 +316,19 @@ bool HeaderMatcher::Match(
 
 std::string HeaderMatcher::ToString() const {
   switch (type_) {
-    case Type::RANGE:
+    case Type::kRange:
       return absl::StrFormat("HeaderMatcher{%s %srange=[%d, %d]}", name_,
                              invert_match_ ? "not " : "", range_start_,
                              range_end_);
-    case Type::PRESENT:
+    case Type::kPresent:
       return absl::StrFormat("HeaderMatcher{%s %spresent=%s}", name_,
                              invert_match_ ? "not " : "",
                              present_match_ ? "true" : "false");
-    case Type::EXACT:
-    case Type::PREFIX:
-    case Type::SUFFIX:
-    case Type::SAFE_REGEX:
-    case Type::CONTAINS:
+    case Type::kExact:
+    case Type::kPrefix:
+    case Type::kSuffix:
+    case Type::kSafeRegex:
+    case Type::kContains:
       return absl::StrFormat("HeaderMatcher{%s %s%s}", name_,
                              invert_match_ ? "not " : "", matcher_.ToString());
     default:

data/src/core/lib/matchers/matchers.h

@@ -31,11 +31,11 @@ namespace grpc_core {
 class StringMatcher {
  public:
   enum class Type {
-    EXACT,       // value stored in string_matcher_ field
-    PREFIX,      // value stored in string_matcher_ field
-    SUFFIX,      // value stored in string_matcher_ field
-    SAFE_REGEX,  // pattern stored in regex_matcher_ field
-    CONTAINS,    // value stored in string_matcher_ field
+    kExact,      // value stored in string_matcher_ field
+    kPrefix,     // value stored in string_matcher_ field
+    kSuffix,     // value stored in string_matcher_ field
+    kSafeRegex,  // pattern stored in regex_matcher_ field
+    kContains,   // value stored in string_matcher_ field
   };
 
   // Creates StringMatcher instance. Returns error status on failure.
@@ -56,10 +56,10 @@ class StringMatcher {
 
   Type type() const { return type_; }
 
-  // Valid for EXACT, PREFIX, SUFFIX and CONTAINS
+  // Valid for kExact, kPrefix, kSuffix and kContains.
   const std::string& string_matcher() const { return string_matcher_; }
 
-  // Valid for SAFE_REGEX
+  // Valid for kSafeRegex.
   RE2* regex_matcher() const { return regex_matcher_.get(); }
 
   bool case_sensitive() const { return case_sensitive_; }
@@ -68,7 +68,7 @@ class StringMatcher {
   StringMatcher(Type type, absl::string_view matcher, bool case_sensitive);
   StringMatcher(std::unique_ptr<RE2> regex_matcher, bool case_sensitive);
 
-  Type type_ = Type::EXACT;
+  Type type_ = Type::kExact;
   std::string string_matcher_;
   std::unique_ptr<RE2> regex_matcher_;
   bool case_sensitive_ = true;
@@ -77,32 +77,32 @@ class StringMatcher {
 class HeaderMatcher {
  public:
   enum class Type {
-    EXACT,       // value stored in StringMatcher field
-    PREFIX,      // value stored in StringMatcher field
-    SUFFIX,      // value stored in StringMatcher field
-    SAFE_REGEX,  // value stored in StringMatcher field
-    CONTAINS,    // value stored in StringMatcher field
-    RANGE,       // uses range_start and range_end fields
-    PRESENT,     // uses present_match field
+    kExact,      // value stored in StringMatcher field
+    kPrefix,     // value stored in StringMatcher field
+    kSuffix,     // value stored in StringMatcher field
+    kSafeRegex,  // value stored in StringMatcher field
+    kContains,   // value stored in StringMatcher field
+    kRange,      // uses range_start and range_end fields
+    kPresent,    // uses present_match field
   };
 
   // Make sure that the first five HeaderMatcher::Type enum values match up to
   // the corresponding StringMatcher::Type enum values, so that it's safe to
   // convert by casting when delegating to StringMatcher.
-  static_assert(static_cast<StringMatcher::Type>(Type::EXACT) ==
-                    StringMatcher::Type::EXACT,
+  static_assert(static_cast<StringMatcher::Type>(Type::kExact) ==
+                    StringMatcher::Type::kExact,
                 "");
-  static_assert(static_cast<StringMatcher::Type>(Type::PREFIX) ==
-                    StringMatcher::Type::PREFIX,
+  static_assert(static_cast<StringMatcher::Type>(Type::kPrefix) ==
+                    StringMatcher::Type::kPrefix,
                 "");
-  static_assert(static_cast<StringMatcher::Type>(Type::SUFFIX) ==
-                    StringMatcher::Type::SUFFIX,
+  static_assert(static_cast<StringMatcher::Type>(Type::kSuffix) ==
+                    StringMatcher::Type::kSuffix,
                 "");
-  static_assert(static_cast<StringMatcher::Type>(Type::SAFE_REGEX) ==
-                    StringMatcher::Type::SAFE_REGEX,
+  static_assert(static_cast<StringMatcher::Type>(Type::kSafeRegex) ==
+                    StringMatcher::Type::kSafeRegex,
                 "");
-  static_assert(static_cast<StringMatcher::Type>(Type::CONTAINS) ==
-                    StringMatcher::Type::CONTAINS,
+  static_assert(static_cast<StringMatcher::Type>(Type::kContains) ==
+                    StringMatcher::Type::kContains,
                 "");
 
   // Creates HeaderMatcher instance. Returns error status on failure.
@@ -124,12 +124,12 @@ class HeaderMatcher {
 
   Type type() const { return type_; }
 
-  // Valid for EXACT, PREFIX, SUFFIX and CONTAINS
+  // Valid for kExact, kPrefix, kSuffix and kContains.
   const std::string& string_matcher() const {
     return matcher_.string_matcher();
   }
 
-  // Valid for SAFE_REGEX
+  // Valid for kSafeRegex.
   RE2* regex_matcher() const { return matcher_.regex_matcher(); }
 
   bool Match(const absl::optional<absl::string_view>& value) const;
@@ -147,7 +147,7 @@ class HeaderMatcher {
   HeaderMatcher(absl::string_view name, bool present_match, bool invert_match);
 
   std::string name_;
-  Type type_ = Type::EXACT;
+  Type type_ = Type::kExact;
   StringMatcher matcher_;
   int64_t range_start_;
   int64_t range_end_;