grpc 1.50.0 → 1.52.0.pre2

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

@@ -55,12 +55,12 @@ bool ExtractJsonNumber(const Json& json, absl::string_view field_name,
                        std::vector<grpc_error_handle>* error_list) {
   static_assert(std::is_integral<NumericType>::value, "Integral required");
   if (json.type() != Json::Type::NUMBER && json.type() != Json::Type::STRING) {
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+    error_list->push_back(GRPC_ERROR_CREATE(absl::StrCat(
         "field:", field_name, " error:type should be NUMBER or STRING")));
     return false;
   }
   if (!absl::SimpleAtoi(json.string_value(), output)) {
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:failed to parse.")));
     return false;
   }
@@ -77,7 +77,7 @@ bool ExtractJsonString(const Json& json, absl::string_view field_name,
                        std::vector<grpc_error_handle>* error_list) {
   if (json.type() != Json::Type::STRING) {
     *output = "";
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be STRING")));
     return false;
   }
@@ -142,7 +142,7 @@ bool ParseJsonObjectField(const Json::Object& object,
   auto it = object.find(std::string(field_name));
   if (it == object.end()) {
     if (required) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      error_list->push_back(GRPC_ERROR_CREATE(
           absl::StrCat("field:", field_name, " error:does not exist.")));
     }
     return false;

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -34,17 +34,17 @@ namespace grpc_core {
 
 namespace {
 
-/* The idea of the writer is basically symmetrical of the reader. While the
- * reader emits various calls to your code, the writer takes basically the
- * same calls and emit json out of it. It doesn't try to make any check on
- * the order of the calls you do on it. Meaning you can theorically force
- * it to generate invalid json.
- *
- * Also, unlike the reader, the writer expects UTF-8 encoded input strings.
- * These strings will be UTF-8 validated, and any invalid character will
- * cut the conversion short, before any invalid UTF-8 sequence, thus forming
- * a valid UTF-8 string overall.
- */
+// The idea of the writer is basically symmetrical of the reader. While the
+// reader emits various calls to your code, the writer takes basically the
+// same calls and emit json out of it. It doesn't try to make any check on
+// the order of the calls you do on it. Meaning you can theorically force
+// it to generate invalid json.
+//
+// Also, unlike the reader, the writer expects UTF-8 encoded input strings.
+// These strings will be UTF-8 validated, and any invalid character will
+// cut the conversion short, before any invalid UTF-8 sequence, thus forming
+// a valid UTF-8 string overall.
+//
 class JsonWriter {
  public:
   static std::string Dump(const Json& value, int indent);
@@ -76,15 +76,15 @@ class JsonWriter {
   std::string output_;
 };
 
-/* This function checks if there's enough space left in the output buffer,
- * and will enlarge it if necessary. We're only allocating chunks of 256
- * bytes at a time (or multiples thereof).
- */
+// This function checks if there's enough space left in the output buffer,
+// and will enlarge it if necessary. We're only allocating chunks of 256
+// bytes at a time (or multiples thereof).
+//
 void JsonWriter::OutputCheck(size_t needed) {
   size_t free_space = output_.capacity() - output_.size();
   if (free_space >= needed) return;
   needed -= free_space;
-  /* Round up by 256 bytes. */
+  // Round up by 256 bytes.
   needed = (needed + 0xff) & ~0xffU;
   output_.reserve(output_.capacity() + needed);
 }
@@ -191,13 +191,13 @@ void JsonWriter::EscapeString(const std::string& string) {
       for (i = 0; i < extra; i++) {
         utf32 <<= 6;
         ++idx;
-        /* Breaks out and bail if we hit the end of the string. */
+        // Breaks out and bail if we hit the end of the string.
         if (idx == string.size()) {
           valid = 0;
           break;
         }
         c = static_cast<uint8_t>(string[idx]);
-        /* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
+        // Breaks out and bail on any invalid UTF-8 sequence, including \0.
         if ((c & 0xc0) != 0x80) {
           valid = 0;
           break;
@@ -205,30 +205,30 @@ void JsonWriter::EscapeString(const std::string& string) {
         utf32 |= c & 0x3f;
       }
       if (!valid) break;
-      /* The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
-       * Any other range is technically reserved for future usage, so if we
-       * don't want the software to break in the future, we have to allow
-       * anything else. The first non-unicode character is 0x110000. */
+      // The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
+      // Any other range is technically reserved for future usage, so if we
+      // don't want the software to break in the future, we have to allow
+      // anything else. The first non-unicode character is 0x110000.
       if (((utf32 >= 0xd800) && (utf32 <= 0xdfff)) || (utf32 >= 0x110000)) {
         break;
       }
       if (utf32 >= 0x10000) {
-        /* If utf32 contains a character that is above 0xffff, it needs to be
-         * broken down into a utf-16 surrogate pair. A surrogate pair is first
-         * a high surrogate, followed by a low surrogate. Each surrogate holds
-         * 10 bits of usable data, thus allowing a total of 20 bits of data.
-         * The high surrogate marker is 0xd800, while the low surrogate marker
-         * is 0xdc00. The low 10 bits of each will be the usable data.
-         *
-         * After re-combining the 20 bits of data, one has to add 0x10000 to
-         * the resulting value, in order to obtain the original character.
-         * This is obviously because the range 0x0000 - 0xffff can be written
-         * without any special trick.
-         *
-         * Since 0x10ffff is the highest allowed character, we're working in
-         * the range 0x00000 - 0xfffff after we decrement it by 0x10000.
-         * That range is exactly 20 bits.
-         */
+        // If utf32 contains a character that is above 0xffff, it needs to be
+        // broken down into a utf-16 surrogate pair. A surrogate pair is first
+        // a high surrogate, followed by a low surrogate. Each surrogate holds
+        // 10 bits of usable data, thus allowing a total of 20 bits of data.
+        // The high surrogate marker is 0xd800, while the low surrogate marker
+        // is 0xdc00. The low 10 bits of each will be the usable data.
+        //
+        // After re-combining the 20 bits of data, one has to add 0x10000 to
+        // the resulting value, in order to obtain the original character.
+        // This is obviously because the range 0x0000 - 0xffff can be written
+        // without any special trick.
+        //
+        // Since 0x10ffff is the highest allowed character, we're working in
+        // the range 0x00000 - 0xfffff after we decrement it by 0x10000.
+        // That range is exactly 20 bits.
+        //
         utf32 -= 0x10000;
         EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
         EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
@@ -283,7 +283,7 @@ void JsonWriter::ValueString(const std::string& string) {
 void JsonWriter::DumpObject(const Json::Object& object) {
   ContainerBegins(Json::Type::OBJECT);
   for (const auto& p : object) {
-    ObjectKey(p.first.data());
+    ObjectKey(p.first);
     DumpValue(p.second);
   }
   ContainerEnds(Json::Type::OBJECT);

data/src/core/lib/load_balancing/lb_policy.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -85,7 +85,7 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
                            DEBUG_LOCATION);
                      },
                      parent, nullptr),
-                 GRPC_ERROR_NONE);
+                 absl::OkStatus());
   }
   return PickResult::Queue();
 }

data/src/core/lib/load_balancing/lb_policy.h

@@ -33,7 +33,8 @@
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -255,10 +256,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// Currently, pickers are always accessed from within the
   /// client_channel data plane mutex, so they do not have to be
   /// thread-safe.
-  class SubchannelPicker {
+  class SubchannelPicker : public RefCounted<SubchannelPicker> {
    public:
     SubchannelPicker() = default;
-    virtual ~SubchannelPicker() = default;
 
     virtual PickResult Pick(PickArgs args) = 0;
   };
@@ -283,7 +283,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// by the client channel.
     virtual void UpdateState(grpc_connectivity_state state,
                              const absl::Status& status,
-                             std::unique_ptr<SubchannelPicker>) = 0;
+                             RefCountedPtr<SubchannelPicker> picker) = 0;
 
     /// Requests that the resolver re-resolve.
     virtual void RequestReresolution() = 0;
@@ -291,6 +291,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Returns the channel authority.
     virtual absl::string_view GetAuthority() = 0;
 
+    /// Returns the EventEngine to use for timers and async work.
+    virtual grpc_event_engine::experimental::EventEngine* GetEventEngine() = 0;
+
     /// Adds a trace message associated with the channel.
     enum TraceSeverity { TRACE_INFO, TRACE_WARNING, TRACE_ERROR };
     virtual void AddTraceEvent(TraceSeverity severity,

data/src/core/lib/load_balancing/subchannel_interface.h

@@ -24,9 +24,8 @@
 
 #include "absl/status/status.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -96,9 +95,6 @@ class SubchannelInterface : public RefCounted<SubchannelInterface> {
   // Registers a new data watcher.
   virtual void AddDataWatcher(
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
-
-  // TODO(roth): Need a better non-grpc-specific abstraction here.
-  virtual ChannelArgs channel_args() = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -124,9 +120,6 @@ class DelegatingSubchannel : public SubchannelInterface {
     wrapped_subchannel_->RequestConnection();
   }
   void ResetBackoff() override { wrapped_subchannel_->ResetBackoff(); }
-  ChannelArgs channel_args() override {
-    return wrapped_subchannel_->channel_args();
-  }
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
     wrapped_subchannel_->AddDataWatcher(std::move(watcher));
   }

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

@@ -18,11 +18,11 @@
 
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 namespace grpc_core {
@@ -35,10 +35,11 @@ absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
                                                     absl::string_view matcher,
                                                     bool case_sensitive) {
   if (type == Type::kSafeRegex) {
-    auto regex_matcher = absl::make_unique<RE2>(std::string(matcher));
+    auto regex_matcher = std::make_unique<RE2>(std::string(matcher));
     if (!regex_matcher->ok()) {
       return absl::InvalidArgumentError(
-          "Invalid regex string specified in matcher.");
+          absl::StrCat("Invalid regex string specified in matcher: ",
+                       regex_matcher->error()));
     }
     return StringMatcher(std::move(regex_matcher));
   } else {
@@ -56,7 +57,7 @@ StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher)
 StringMatcher::StringMatcher(const StringMatcher& other)
     : type_(other.type_), case_sensitive_(other.case_sensitive_) {
   if (type_ == Type::kSafeRegex) {
-    regex_matcher_ = absl::make_unique<RE2>(other.regex_matcher_->pattern());
+    regex_matcher_ = std::make_unique<RE2>(other.regex_matcher_->pattern());
   } else {
     string_matcher_ = other.string_matcher_;
   }
@@ -65,7 +66,7 @@ StringMatcher::StringMatcher(const StringMatcher& other)
 StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
   type_ = other.type_;
   if (type_ == Type::kSafeRegex) {
-    regex_matcher_ = absl::make_unique<RE2>(other.regex_matcher_->pattern());
+    regex_matcher_ = std::make_unique<RE2>(other.regex_matcher_->pattern());
   } else {
     string_matcher_ = other.string_matcher_;
   }

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

@@ -159,4 +159,4 @@ class HeaderMatcher {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_MATCHERS_MATCHERS_H */
+#endif  // GRPC_CORE_LIB_MATCHERS_MATCHERS_H

data/src/core/lib/promise/activity.cc

@@ -18,6 +18,8 @@
 
 #include <stddef.h>
 
+#include "absl/strings/str_format.h"
+
 #include "src/core/lib/gprpp/atomic_utils.h"
 
 namespace grpc_core {
@@ -25,13 +27,15 @@ namespace grpc_core {
 ///////////////////////////////////////////////////////////////////////////////
 // GLOBALS
 
-GPR_THREAD_LOCAL(Activity*) Activity::g_current_activity_{nullptr};
+thread_local Activity* Activity::g_current_activity_{nullptr};
 
 namespace promise_detail {
 
 ///////////////////////////////////////////////////////////////////////////////
 // HELPER TYPES
 
+std::string Unwakeable::ActivityDebugTag() const { return "<unknown>"; }
+
 // Weak handle to an Activity.
 // Handle can persist while Activity goes away.
 class FreestandingActivity::Handle final : public Wakeable {
@@ -74,6 +78,11 @@ class FreestandingActivity::Handle final : public Wakeable {
 
   void Drop() override { Unref(); }
 
+  std::string ActivityDebugTag() const override {
+    MutexLock lock(&mu_);
+    return activity_ == nullptr ? "<unknown>" : activity_->DebugTag();
+  }
+
  private:
   // Unref the Handle (not the activity).
   void Unref() {
@@ -85,7 +94,7 @@ class FreestandingActivity::Handle final : public Wakeable {
   // Two initial refs: one for the waiter that caused instantiation, one for the
   // activity.
   std::atomic<size_t> refs_{2};
-  Mutex mu_ ABSL_ACQUIRED_AFTER(activity_->mu_);
+  mutable Mutex mu_ ABSL_ACQUIRED_AFTER(activity_->mu_);
   FreestandingActivity* activity_ ABSL_GUARDED_BY(mu_);
 };
 
@@ -117,4 +126,9 @@ Waker FreestandingActivity::MakeNonOwningWaker() {
 }
 
 }  // namespace promise_detail
+
+std::string Activity::DebugTag() const {
+  return absl::StrFormat("ACTIVITY[%p]", this);
+}
+
 }  // namespace grpc_core