Restoring authorship annotation for <dvshkurko@yandex-team.ru>. Commit 1 of 2.

11 files changed, 316 insertions, 316 deletions

diff --git a/contrib/libs/grpc/src/cpp/client/channel_cc.cc b/contrib/libs/grpc/src/cpp/client/channel_cc.cc
index ac95c29efc..0d3fcc1444 100644
--- a/contrib/libs/grpc/src/cpp/client/channel_cc.cc
+++ b/contrib/libs/grpc/src/cpp/client/channel_cc.cc
@@ -43,11 +43,11 @@
 
 namespace grpc {
 
-static ::grpc::internal::GrpcLibraryInitializer g_gli_initializer;
+static ::grpc::internal::GrpcLibraryInitializer g_gli_initializer; 
 Channel::Channel(const TString& host, grpc_channel* channel,
-                 std::vector<std::unique_ptr<
-                     ::grpc::experimental::ClientInterceptorFactoryInterface>>
-                     interceptor_creators)
+                 std::vector<std::unique_ptr< 
+                     ::grpc::experimental::ClientInterceptorFactoryInterface>> 
+                     interceptor_creators) 
     : host_(host), c_channel_(channel) {
   interceptor_creators_ = std::move(interceptor_creators);
   g_gli_initializer.summon();
@@ -101,9 +101,9 @@ void ChannelResetConnectionBackoff(Channel* channel) {
 
 }  // namespace experimental
 
-::grpc::internal::Call Channel::CreateCallInternal(
-    const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context,
-    ::grpc::CompletionQueue* cq, size_t interceptor_pos) {
+::grpc::internal::Call Channel::CreateCallInternal( 
+    const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context, 
+    ::grpc::CompletionQueue* cq, size_t interceptor_pos) { 
   const bool kRegistered = method.channel_tag() && context->authority().empty();
   grpc_call* c_call = nullptr;
   if (kRegistered) {
@@ -122,7 +122,7 @@ void ChannelResetConnectionBackoff(Channel* channel) {
         SliceFromArray(method.name(), strlen(method.name()));
     grpc_slice host_slice;
     if (host_str != nullptr) {
-      host_slice = ::grpc::SliceFromCopiedString(*host_str);
+      host_slice = ::grpc::SliceFromCopiedString(*host_str); 
     }
     c_call = grpc_channel_create_call(
         c_channel_, context->propagate_from_call_,
@@ -138,23 +138,23 @@ void ChannelResetConnectionBackoff(Channel* channel) {
 
   // ClientRpcInfo should be set before call because set_call also checks
   // whether the call has been cancelled, and if the call was cancelled, we
-  // should notify the interceptors too.
+  // should notify the interceptors too. 
   auto* info =
       context->set_client_rpc_info(method.name(), method.method_type(), this,
                                    interceptor_creators_, interceptor_pos);
   context->set_call(c_call, shared_from_this());
 
-  return ::grpc::internal::Call(c_call, this, cq, info);
+  return ::grpc::internal::Call(c_call, this, cq, info); 
 }
 
-::grpc::internal::Call Channel::CreateCall(
-    const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context,
-    CompletionQueue* cq) {
+::grpc::internal::Call Channel::CreateCall( 
+    const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context, 
+    CompletionQueue* cq) { 
   return CreateCallInternal(method, context, cq, 0);
 }
 
-void Channel::PerformOpsOnCall(::grpc::internal::CallOpSetInterface* ops,
-                               ::grpc::internal::Call* call) {
+void Channel::PerformOpsOnCall(::grpc::internal::CallOpSetInterface* ops, 
+                               ::grpc::internal::Call* call) { 
   ops->FillOps(
       call);  // Make a copy of call. It's fine since Call just has pointers
 }
@@ -170,11 +170,11 @@ grpc_connectivity_state Channel::GetState(bool try_to_connect) {
 
 namespace {
 
-class TagSaver final : public ::grpc::internal::CompletionQueueTag {
+class TagSaver final : public ::grpc::internal::CompletionQueueTag { 
  public:
   explicit TagSaver(void* tag) : tag_(tag) {}
   ~TagSaver() override {}
-  bool FinalizeResult(void** tag, bool* /*status*/) override {
+  bool FinalizeResult(void** tag, bool* /*status*/) override { 
     *tag = tag_;
     delete this;
     return true;
@@ -188,7 +188,7 @@ class TagSaver final : public ::grpc::internal::CompletionQueueTag {
 
 void Channel::NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
                                       gpr_timespec deadline,
-                                      ::grpc::CompletionQueue* cq, void* tag) {
+                                      ::grpc::CompletionQueue* cq, void* tag) { 
   TagSaver* tag_saver = new TagSaver(tag);
   grpc_channel_watch_connectivity_state(c_channel_, last_observed, deadline,
                                         cq->cq(), tag_saver);
@@ -196,7 +196,7 @@ void Channel::NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
 
 bool Channel::WaitForStateChangeImpl(grpc_connectivity_state last_observed,
                                      gpr_timespec deadline) {
-  ::grpc::CompletionQueue cq;
+  ::grpc::CompletionQueue cq; 
   bool ok = false;
   void* tag = nullptr;
   NotifyOnStateChangeImpl(last_observed, deadline, &cq, nullptr);
@@ -208,17 +208,17 @@ bool Channel::WaitForStateChangeImpl(grpc_connectivity_state last_observed,
 namespace {
 class ShutdownCallback : public grpc_experimental_completion_queue_functor {
  public:
-  ShutdownCallback() {
-    functor_run = &ShutdownCallback::Run;
-    // Set inlineable to true since this callback is trivial and thus does not
-    // need to be run from the executor (triggering a thread hop). This should
-    // only be used by internal callbacks like this and not by user application
-    // code.
-    inlineable = true;
-  }
+  ShutdownCallback() { 
+    functor_run = &ShutdownCallback::Run; 
+    // Set inlineable to true since this callback is trivial and thus does not 
+    // need to be run from the executor (triggering a thread hop). This should 
+    // only be used by internal callbacks like this and not by user application 
+    // code. 
+    inlineable = true; 
+  } 
   // TakeCQ takes ownership of the cq into the shutdown callback
   // so that the shutdown callback will be responsible for destroying it
-  void TakeCQ(::grpc::CompletionQueue* cq) { cq_ = cq; }
+  void TakeCQ(::grpc::CompletionQueue* cq) { cq_ = cq; } 
 
   // The Run function will get invoked by the completion queue library
   // when the shutdown is actually complete
@@ -229,17 +229,17 @@ class ShutdownCallback : public grpc_experimental_completion_queue_functor {
   }
 
  private:
-  ::grpc::CompletionQueue* cq_ = nullptr;
+  ::grpc::CompletionQueue* cq_ = nullptr; 
 };
 }  // namespace
 
-::grpc::CompletionQueue* Channel::CallbackCQ() {
+::grpc::CompletionQueue* Channel::CallbackCQ() { 
   // TODO(vjpai): Consider using a single global CQ for the default CQ
   // if there is no explicit per-channel CQ registered
-  grpc::internal::MutexLock l(&mu_);
+  grpc::internal::MutexLock l(&mu_); 
   if (callback_cq_ == nullptr) {
     auto* shutdown_callback = new ShutdownCallback;
-    callback_cq_ = new ::grpc::CompletionQueue(grpc_completion_queue_attributes{
+    callback_cq_ = new ::grpc::CompletionQueue(grpc_completion_queue_attributes{ 
         GRPC_CQ_CURRENT_VERSION, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING,
         shutdown_callback});
 
diff --git a/contrib/libs/grpc/src/cpp/client/client_context.cc b/contrib/libs/grpc/src/cpp/client/client_context.cc
index b75343d089..e3cb5cef57 100644
--- a/contrib/libs/grpc/src/cpp/client/client_context.cc
+++ b/contrib/libs/grpc/src/cpp/client/client_context.cc
@@ -25,7 +25,7 @@
 #include <grpc/support/string_util.h>
 
 #include <grpcpp/impl/codegen/interceptor_common.h>
-#include <grpcpp/impl/codegen/sync.h>
+#include <grpcpp/impl/codegen/sync.h> 
 #include <grpcpp/impl/grpc_library.h>
 #include <grpcpp/security/credentials.h>
 #include <grpcpp/server_context.h>
@@ -33,14 +33,14 @@
 
 namespace grpc {
 
-class Channel;
-
+class Channel; 
+ 
 class DefaultGlobalClientCallbacks final
     : public ClientContext::GlobalCallbacks {
  public:
   ~DefaultGlobalClientCallbacks() override {}
-  void DefaultConstructor(ClientContext* /*context*/) override {}
-  void Destructor(ClientContext* /*context*/) override {}
+  void DefaultConstructor(ClientContext* /*context*/) override {} 
+  void Destructor(ClientContext* /*context*/) override {} 
 };
 
 static internal::GrpcLibraryInitializer g_gli_initializer;
@@ -72,23 +72,23 @@ ClientContext::~ClientContext() {
   g_client_callbacks->Destructor(this);
 }
 
-void ClientContext::set_credentials(
+void ClientContext::set_credentials( 
     const std::shared_ptr<CallCredentials>& creds) {
-  creds_ = creds;
-  // If call_ is set, we have already created the call, and set the call
-  // credentials. This should only be done before we have started the batch
-  // for sending initial metadata.
-  if (creds_ != nullptr && call_ != nullptr) {
-    if (!creds_->ApplyToCall(call_)) {
-      SendCancelToInterceptors();
-      grpc_call_cancel_with_status(call_, GRPC_STATUS_CANCELLED,
-                                   "Failed to set credentials to rpc.",
-                                   nullptr);
-    }
-  }
-}
-
-std::unique_ptr<ClientContext> ClientContext::FromInternalServerContext(
+  creds_ = creds; 
+  // If call_ is set, we have already created the call, and set the call 
+  // credentials. This should only be done before we have started the batch 
+  // for sending initial metadata. 
+  if (creds_ != nullptr && call_ != nullptr) { 
+    if (!creds_->ApplyToCall(call_)) { 
+      SendCancelToInterceptors(); 
+      grpc_call_cancel_with_status(call_, GRPC_STATUS_CANCELLED, 
+                                   "Failed to set credentials to rpc.", 
+                                   nullptr); 
+    } 
+  } 
+} 
+ 
+std::unique_ptr<ClientContext> ClientContext::FromInternalServerContext( 
     const grpc::ServerContextBase& context, PropagationOptions options) {
   std::unique_ptr<ClientContext> ctx(new ClientContext);
   ctx->propagate_from_call_ = context.call_.call;
@@ -96,17 +96,17 @@ std::unique_ptr<ClientContext> ClientContext::FromInternalServerContext(
   return ctx;
 }
 
-std::unique_ptr<ClientContext> ClientContext::FromServerContext(
+std::unique_ptr<ClientContext> ClientContext::FromServerContext( 
     const grpc::ServerContext& server_context, PropagationOptions options) {
-  return FromInternalServerContext(server_context, options);
-}
-
-std::unique_ptr<ClientContext> ClientContext::FromCallbackServerContext(
+  return FromInternalServerContext(server_context, options); 
+} 
+ 
+std::unique_ptr<ClientContext> ClientContext::FromCallbackServerContext( 
     const grpc::CallbackServerContext& server_context,
-    PropagationOptions options) {
-  return FromInternalServerContext(server_context, options);
-}
-
+    PropagationOptions options) { 
+  return FromInternalServerContext(server_context, options); 
+} 
+ 
 void ClientContext::AddMetadata(const TString& meta_key,
                                 const TString& meta_value) {
   send_initial_metadata_.insert(std::make_pair(meta_key, meta_value));
diff --git a/contrib/libs/grpc/src/cpp/client/client_interceptor.cc b/contrib/libs/grpc/src/cpp/client/client_interceptor.cc
index a91950cae2..9b2f03b49a 100644
--- a/contrib/libs/grpc/src/cpp/client/client_interceptor.cc
+++ b/contrib/libs/grpc/src/cpp/client/client_interceptor.cc
@@ -28,17 +28,17 @@ experimental::ClientInterceptorFactoryInterface*
 namespace experimental {
 void RegisterGlobalClientInterceptorFactory(
     ClientInterceptorFactoryInterface* factory) {
-  if (internal::g_global_client_interceptor_factory != nullptr) {
-    GPR_ASSERT(false &&
-               "It is illegal to call RegisterGlobalClientInterceptorFactory "
-               "multiple times.");
-  }
+  if (internal::g_global_client_interceptor_factory != nullptr) { 
+    GPR_ASSERT(false && 
+               "It is illegal to call RegisterGlobalClientInterceptorFactory " 
+               "multiple times."); 
+  } 
   internal::g_global_client_interceptor_factory = factory;
 }
-
-// For testing purposes only.
-void TestOnlyResetGlobalClientInterceptorFactory() {
-  internal::g_global_client_interceptor_factory = nullptr;
-}
+ 
+// For testing purposes only. 
+void TestOnlyResetGlobalClientInterceptorFactory() { 
+  internal::g_global_client_interceptor_factory = nullptr; 
+} 
 }  // namespace experimental
 }  // namespace grpc
diff --git a/contrib/libs/grpc/src/cpp/client/create_channel.cc b/contrib/libs/grpc/src/cpp/client/create_channel.cc
index 97327490ed..0a3863e83f 100644
--- a/contrib/libs/grpc/src/cpp/client/create_channel.cc
+++ b/contrib/libs/grpc/src/cpp/client/create_channel.cc
@@ -21,7 +21,7 @@
 #include <grpcpp/channel.h>
 #include <grpcpp/create_channel.h>
 #include <grpcpp/impl/grpc_library.h>
-#include <grpcpp/security/credentials.h>
+#include <grpcpp/security/credentials.h> 
 #include <grpcpp/support/channel_arguments.h>
 
 #include "src/cpp/client/create_channel_internal.h"
@@ -29,25 +29,25 @@
 namespace grpc {
 std::shared_ptr<grpc::Channel> CreateChannel(
     const grpc::string& target,
-    const std::shared_ptr<grpc::ChannelCredentials>& creds) {
+    const std::shared_ptr<grpc::ChannelCredentials>& creds) { 
   return CreateCustomChannel(target, creds, grpc::ChannelArguments());
 }
 
 std::shared_ptr<grpc::Channel> CreateCustomChannel(
     const grpc::string& target,
-    const std::shared_ptr<grpc::ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args) {
-  grpc::GrpcLibraryCodegen
-      init_lib;  // We need to call init in case of bad creds.
-  return creds ? creds->CreateChannelImpl(target, args)
-               : grpc::CreateChannelInternal(
+    const std::shared_ptr<grpc::ChannelCredentials>& creds, 
+    const grpc::ChannelArguments& args) { 
+  grpc::GrpcLibraryCodegen 
+      init_lib;  // We need to call init in case of bad creds. 
+  return creds ? creds->CreateChannelImpl(target, args) 
+               : grpc::CreateChannelInternal( 
                      "",
                      grpc_lame_client_channel_create(
                          nullptr, GRPC_STATUS_INVALID_ARGUMENT,
                          "Invalid credentials."),
                      std::vector<std::unique_ptr<
-                         grpc::experimental::
-                             ClientInterceptorFactoryInterface>>());
+                         grpc::experimental:: 
+                             ClientInterceptorFactoryInterface>>()); 
 }
 
 namespace experimental {
@@ -62,23 +62,23 @@ namespace experimental {
 /// hold an object or is invalid, a lame channel (one on which all operations
 /// fail) is returned.
 /// \param args Options for channel creation.
-std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
+std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors( 
     const TString& target,
-    const std::shared_ptr<grpc::ChannelCredentials>& creds,
-    const grpc::ChannelArguments& args,
+    const std::shared_ptr<grpc::ChannelCredentials>& creds, 
+    const grpc::ChannelArguments& args, 
     std::vector<
-        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> 
         interceptor_creators) {
-  grpc::GrpcLibraryCodegen
-      init_lib;  // We need to call init in case of bad creds.
+  grpc::GrpcLibraryCodegen 
+      init_lib;  // We need to call init in case of bad creds. 
   return creds ? creds->CreateChannelWithInterceptors(
                      target, args, std::move(interceptor_creators))
-               : grpc::CreateChannelInternal(
+               : grpc::CreateChannelInternal( 
                      "",
                      grpc_lame_client_channel_create(
                          nullptr, GRPC_STATUS_INVALID_ARGUMENT,
                          "Invalid credentials."),
-                     std::move(interceptor_creators));
+                     std::move(interceptor_creators)); 
 }
 }  // namespace experimental
 
diff --git a/contrib/libs/grpc/src/cpp/client/create_channel_internal.cc b/contrib/libs/grpc/src/cpp/client/create_channel_internal.cc
index da2a878a22..a1ce29c8c0 100644
--- a/contrib/libs/grpc/src/cpp/client/create_channel_internal.cc
+++ b/contrib/libs/grpc/src/cpp/client/create_channel_internal.cc
@@ -26,11 +26,11 @@ namespace grpc {
 
 std::shared_ptr<Channel> CreateChannelInternal(
     const TString& host, grpc_channel* c_channel,
-    std::vector<std::unique_ptr<
-        ::grpc::experimental::ClientInterceptorFactoryInterface>>
+    std::vector<std::unique_ptr< 
+        ::grpc::experimental::ClientInterceptorFactoryInterface>> 
         interceptor_creators) {
   return std::shared_ptr<Channel>(
       new Channel(host, c_channel, std::move(interceptor_creators)));
 }
-
+ 
 }  // namespace grpc
diff --git a/contrib/libs/grpc/src/cpp/client/create_channel_internal.h b/contrib/libs/grpc/src/cpp/client/create_channel_internal.h
index 09d4e56b02..8932d12a4f 100644
--- a/contrib/libs/grpc/src/cpp/client/create_channel_internal.h
+++ b/contrib/libs/grpc/src/cpp/client/create_channel_internal.h
@@ -21,7 +21,7 @@
 
 #include <memory>
 
-#include <grpcpp/channel.h>
+#include <grpcpp/channel.h> 
 #include <grpcpp/impl/codegen/client_interceptor.h>
 #include <grpcpp/support/config.h>
 
@@ -31,8 +31,8 @@ namespace grpc {
 
 std::shared_ptr<Channel> CreateChannelInternal(
     const TString& host, grpc_channel* c_channel,
-    std::vector<std::unique_ptr<
-        ::grpc::experimental::ClientInterceptorFactoryInterface>>
+    std::vector<std::unique_ptr< 
+        ::grpc::experimental::ClientInterceptorFactoryInterface>> 
         interceptor_creators);
 
 }  // namespace grpc
diff --git a/contrib/libs/grpc/src/cpp/client/create_channel_posix.cc b/contrib/libs/grpc/src/cpp/client/create_channel_posix.cc
index db09eda8a6..57b0cc7da6 100644
--- a/contrib/libs/grpc/src/cpp/client/create_channel_posix.cc
+++ b/contrib/libs/grpc/src/cpp/client/create_channel_posix.cc
@@ -20,19 +20,19 @@
 #include <grpc/grpc_posix.h>
 #include <grpcpp/channel.h>
 #include <grpcpp/impl/grpc_library.h>
-#include <grpcpp/support/channel_arguments.h>
+#include <grpcpp/support/channel_arguments.h> 
 
 #include "src/cpp/client/create_channel_internal.h"
 
 namespace grpc {
 
-class ChannelArguments;
-
+class ChannelArguments; 
+ 
 #ifdef GPR_SUPPORT_CHANNELS_FROM_FD
 
 std::shared_ptr<Channel> CreateInsecureChannelFromFd(const TString& target,
                                                      int fd) {
-  grpc::internal::GrpcLibrary init_lib;
+  grpc::internal::GrpcLibrary init_lib; 
   init_lib.init();
   return CreateChannelInternal(
       "", grpc_insecure_channel_create_from_fd(target.c_str(), fd, nullptr),
@@ -58,9 +58,9 @@ namespace experimental {
 std::shared_ptr<Channel> CreateCustomInsecureChannelWithInterceptorsFromFd(
     const TString& target, int fd, const ChannelArguments& args,
     std::vector<
-        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> 
         interceptor_creators) {
-  grpc::internal::GrpcLibrary init_lib;
+  grpc::internal::GrpcLibrary init_lib; 
   init_lib.init();
   grpc_channel_args channel_args;
   args.SetChannelArgs(&channel_args);
diff --git a/contrib/libs/grpc/src/cpp/client/credentials_cc.cc b/contrib/libs/grpc/src/cpp/client/credentials_cc.cc
index 9dfb2f491c..99cf583f72 100644
--- a/contrib/libs/grpc/src/cpp/client/credentials_cc.cc
+++ b/contrib/libs/grpc/src/cpp/client/credentials_cc.cc
@@ -21,7 +21,7 @@
 
 namespace grpc {
 
-static grpc::internal::GrpcLibraryInitializer g_gli_initializer;
+static grpc::internal::GrpcLibraryInitializer g_gli_initializer; 
 ChannelCredentials::ChannelCredentials() { g_gli_initializer.summon(); }
 
 ChannelCredentials::~ChannelCredentials() {}
diff --git a/contrib/libs/grpc/src/cpp/client/insecure_credentials.cc b/contrib/libs/grpc/src/cpp/client/insecure_credentials.cc
index e5bafff70a..8820efb1ee 100644
--- a/contrib/libs/grpc/src/cpp/client/insecure_credentials.cc
+++ b/contrib/libs/grpc/src/cpp/client/insecure_credentials.cc
@@ -29,22 +29,22 @@ namespace grpc {
 namespace {
 class InsecureChannelCredentialsImpl final : public ChannelCredentials {
  public:
-  std::shared_ptr<Channel> CreateChannelImpl(
+  std::shared_ptr<Channel> CreateChannelImpl( 
       const TString& target, const ChannelArguments& args) override {
     return CreateChannelWithInterceptors(
         target, args,
         std::vector<std::unique_ptr<
-            grpc::experimental::ClientInterceptorFactoryInterface>>());
+            grpc::experimental::ClientInterceptorFactoryInterface>>()); 
   }
 
-  std::shared_ptr<Channel> CreateChannelWithInterceptors(
+  std::shared_ptr<Channel> CreateChannelWithInterceptors( 
       const TString& target, const ChannelArguments& args,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>
+      std::vector<std::unique_ptr< 
+          grpc::experimental::ClientInterceptorFactoryInterface>> 
           interceptor_creators) override {
     grpc_channel_args channel_args;
     args.SetChannelArgs(&channel_args);
-    return ::grpc::CreateChannelInternal(
+    return ::grpc::CreateChannelInternal( 
         "",
         grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr),
         std::move(interceptor_creators));
diff --git a/contrib/libs/grpc/src/cpp/client/secure_credentials.cc b/contrib/libs/grpc/src/cpp/client/secure_credentials.cc
index 0f6db3caa5..c31d8fef8e 100644
--- a/contrib/libs/grpc/src/cpp/client/secure_credentials.cc
+++ b/contrib/libs/grpc/src/cpp/client/secure_credentials.cc
@@ -17,53 +17,53 @@
  */
 
 #include "src/cpp/client/secure_credentials.h"
-
-#include <grpc/impl/codegen/slice.h>
-#include <grpc/slice.h>
+ 
+#include <grpc/impl/codegen/slice.h> 
+#include <grpc/slice.h> 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpcpp/channel.h>
-#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/status.h> 
 #include <grpcpp/impl/grpc_library.h>
 #include <grpcpp/support/channel_arguments.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/load_file.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/security/transport/auth_filters.h"
-#include "src/core/lib/security/util/json_util.h"
+ 
+#include "src/core/lib/gpr/env.h" 
+#include "src/core/lib/iomgr/error.h" 
+#include "src/core/lib/iomgr/executor.h" 
+#include "src/core/lib/iomgr/load_file.h" 
+#include "src/core/lib/json/json.h" 
+#include "src/core/lib/security/transport/auth_filters.h" 
+#include "src/core/lib/security/util/json_util.h" 
 #include "src/cpp/client/create_channel_internal.h"
 #include "src/cpp/common/secure_auth_context.h"
 
 namespace grpc {
 
-static grpc::internal::GrpcLibraryInitializer g_gli_initializer;
+static grpc::internal::GrpcLibraryInitializer g_gli_initializer; 
 SecureChannelCredentials::SecureChannelCredentials(
     grpc_channel_credentials* c_creds)
     : c_creds_(c_creds) {
   g_gli_initializer.summon();
 }
 
-std::shared_ptr<Channel> SecureChannelCredentials::CreateChannelImpl(
+std::shared_ptr<Channel> SecureChannelCredentials::CreateChannelImpl( 
     const TString& target, const ChannelArguments& args) {
   return CreateChannelWithInterceptors(
       target, args,
-      std::vector<std::unique_ptr<
-          grpc::experimental::ClientInterceptorFactoryInterface>>());
+      std::vector<std::unique_ptr< 
+          grpc::experimental::ClientInterceptorFactoryInterface>>()); 
 }
 
-std::shared_ptr<Channel>
+std::shared_ptr<Channel> 
 SecureChannelCredentials::CreateChannelWithInterceptors(
     const TString& target, const ChannelArguments& args,
     std::vector<
-        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
+        std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> 
         interceptor_creators) {
   grpc_channel_args channel_args;
   args.SetChannelArgs(&channel_args);
-  return ::grpc::CreateChannelInternal(
+  return ::grpc::CreateChannelInternal( 
       args.GetSslTargetNameOverride(),
       grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args,
                                  nullptr),
@@ -96,7 +96,7 @@ std::shared_ptr<CallCredentials> WrapCallCredentials(
 }  // namespace
 
 std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials() {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapChannelCredentials(
       grpc_google_default_credentials_create(nullptr));
 }
@@ -104,7 +104,7 @@ std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials() {
 // Builds SSL Credentials given SSL specific options
 std::shared_ptr<ChannelCredentials> SslCredentials(
     const SslCredentialsOptions& options) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {
       options.pem_private_key.c_str(), options.pem_cert_chain.c_str()};
 
@@ -117,139 +117,139 @@ std::shared_ptr<ChannelCredentials> SslCredentials(
 
 namespace experimental {
 
-namespace {
-
-void ClearStsCredentialsOptions(StsCredentialsOptions* options) {
-  if (options == nullptr) return;
-  options->token_exchange_service_uri.clear();
-  options->resource.clear();
-  options->audience.clear();
-  options->scope.clear();
-  options->requested_token_type.clear();
-  options->subject_token_path.clear();
-  options->subject_token_type.clear();
-  options->actor_token_path.clear();
-  options->actor_token_type.clear();
-}
-
-}  // namespace
-
-// Builds STS credentials options from JSON.
+namespace { 
+ 
+void ClearStsCredentialsOptions(StsCredentialsOptions* options) { 
+  if (options == nullptr) return; 
+  options->token_exchange_service_uri.clear(); 
+  options->resource.clear(); 
+  options->audience.clear(); 
+  options->scope.clear(); 
+  options->requested_token_type.clear(); 
+  options->subject_token_path.clear(); 
+  options->subject_token_type.clear(); 
+  options->actor_token_path.clear(); 
+  options->actor_token_type.clear(); 
+} 
+ 
+}  // namespace 
+ 
+// Builds STS credentials options from JSON. 
 grpc::Status StsCredentialsOptionsFromJson(const TString& json_string,
-                                           StsCredentialsOptions* options) {
-  if (options == nullptr) {
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT,
-                        "options cannot be nullptr.");
-  }
-  ClearStsCredentialsOptions(options);
+                                           StsCredentialsOptions* options) { 
+  if (options == nullptr) { 
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, 
+                        "options cannot be nullptr."); 
+  } 
+  ClearStsCredentialsOptions(options); 
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_core::Json json = grpc_core::Json::Parse(json_string.c_str(), &error);
   if (error != GRPC_ERROR_NONE ||
       json.type() != grpc_core::Json::Type::OBJECT) {
     GRPC_ERROR_UNREF(error);
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "Invalid json.");
-  }
-
-  // Required fields.
-  const char* value = grpc_json_get_string_property(
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, "Invalid json."); 
+  } 
+ 
+  // Required fields. 
+  const char* value = grpc_json_get_string_property( 
       json, "token_exchange_service_uri", nullptr);
-  if (value == nullptr) {
-    ClearStsCredentialsOptions(options);
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT,
-                        "token_exchange_service_uri must be specified.");
-  }
-  options->token_exchange_service_uri.assign(value);
+  if (value == nullptr) { 
+    ClearStsCredentialsOptions(options); 
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, 
+                        "token_exchange_service_uri must be specified."); 
+  } 
+  options->token_exchange_service_uri.assign(value); 
   value = grpc_json_get_string_property(json, "subject_token_path", nullptr);
-  if (value == nullptr) {
-    ClearStsCredentialsOptions(options);
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT,
-                        "subject_token_path must be specified.");
-  }
-  options->subject_token_path.assign(value);
+  if (value == nullptr) { 
+    ClearStsCredentialsOptions(options); 
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, 
+                        "subject_token_path must be specified."); 
+  } 
+  options->subject_token_path.assign(value); 
   value = grpc_json_get_string_property(json, "subject_token_type", nullptr);
-  if (value == nullptr) {
-    ClearStsCredentialsOptions(options);
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT,
-                        "subject_token_type must be specified.");
-  }
-  options->subject_token_type.assign(value);
-
-  // Optional fields.
+  if (value == nullptr) { 
+    ClearStsCredentialsOptions(options); 
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, 
+                        "subject_token_type must be specified."); 
+  } 
+  options->subject_token_type.assign(value); 
+ 
+  // Optional fields. 
   value = grpc_json_get_string_property(json, "resource", nullptr);
-  if (value != nullptr) options->resource.assign(value);
+  if (value != nullptr) options->resource.assign(value); 
   value = grpc_json_get_string_property(json, "audience", nullptr);
-  if (value != nullptr) options->audience.assign(value);
+  if (value != nullptr) options->audience.assign(value); 
   value = grpc_json_get_string_property(json, "scope", nullptr);
-  if (value != nullptr) options->scope.assign(value);
+  if (value != nullptr) options->scope.assign(value); 
   value = grpc_json_get_string_property(json, "requested_token_type", nullptr);
-  if (value != nullptr) options->requested_token_type.assign(value);
+  if (value != nullptr) options->requested_token_type.assign(value); 
   value = grpc_json_get_string_property(json, "actor_token_path", nullptr);
-  if (value != nullptr) options->actor_token_path.assign(value);
+  if (value != nullptr) options->actor_token_path.assign(value); 
   value = grpc_json_get_string_property(json, "actor_token_type", nullptr);
-  if (value != nullptr) options->actor_token_type.assign(value);
-
-  return grpc::Status();
-}
-
-// Builds STS credentials Options from the $STS_CREDENTIALS env var.
-grpc::Status StsCredentialsOptionsFromEnv(StsCredentialsOptions* options) {
-  if (options == nullptr) {
-    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT,
-                        "options cannot be nullptr.");
-  }
-  ClearStsCredentialsOptions(options);
-  grpc_slice json_string = grpc_empty_slice();
-  char* sts_creds_path = gpr_getenv("STS_CREDENTIALS");
-  grpc_error* error = GRPC_ERROR_NONE;
-  grpc::Status status;
-  auto cleanup = [&json_string, &sts_creds_path, &error, &status]() {
-    grpc_slice_unref_internal(json_string);
-    gpr_free(sts_creds_path);
-    GRPC_ERROR_UNREF(error);
-    return status;
-  };
-
-  if (sts_creds_path == nullptr) {
-    status = grpc::Status(grpc::StatusCode::NOT_FOUND,
-                          "STS_CREDENTIALS environment variable not set.");
-    return cleanup();
-  }
-  error = grpc_load_file(sts_creds_path, 1, &json_string);
-  if (error != GRPC_ERROR_NONE) {
-    status =
-        grpc::Status(grpc::StatusCode::NOT_FOUND, grpc_error_string(error));
-    return cleanup();
-  }
-  status = StsCredentialsOptionsFromJson(
-      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(json_string)),
-      options);
-  return cleanup();
-}
-
-// C++ to Core STS Credentials options.
-grpc_sts_credentials_options StsCredentialsCppToCoreOptions(
-    const StsCredentialsOptions& options) {
-  grpc_sts_credentials_options opts;
-  memset(&opts, 0, sizeof(opts));
-  opts.token_exchange_service_uri = options.token_exchange_service_uri.c_str();
-  opts.resource = options.resource.c_str();
-  opts.audience = options.audience.c_str();
-  opts.scope = options.scope.c_str();
-  opts.requested_token_type = options.requested_token_type.c_str();
-  opts.subject_token_path = options.subject_token_path.c_str();
-  opts.subject_token_type = options.subject_token_type.c_str();
-  opts.actor_token_path = options.actor_token_path.c_str();
-  opts.actor_token_type = options.actor_token_type.c_str();
-  return opts;
-}
-
-// Builds STS credentials.
-std::shared_ptr<CallCredentials> StsCredentials(
-    const StsCredentialsOptions& options) {
-  auto opts = StsCredentialsCppToCoreOptions(options);
-  return WrapCallCredentials(grpc_sts_credentials_create(&opts, nullptr));
-}
-
+  if (value != nullptr) options->actor_token_type.assign(value); 
+ 
+  return grpc::Status(); 
+} 
+ 
+// Builds STS credentials Options from the $STS_CREDENTIALS env var. 
+grpc::Status StsCredentialsOptionsFromEnv(StsCredentialsOptions* options) { 
+  if (options == nullptr) { 
+    return grpc::Status(grpc::StatusCode::INVALID_ARGUMENT, 
+                        "options cannot be nullptr."); 
+  } 
+  ClearStsCredentialsOptions(options); 
+  grpc_slice json_string = grpc_empty_slice(); 
+  char* sts_creds_path = gpr_getenv("STS_CREDENTIALS"); 
+  grpc_error* error = GRPC_ERROR_NONE; 
+  grpc::Status status; 
+  auto cleanup = [&json_string, &sts_creds_path, &error, &status]() { 
+    grpc_slice_unref_internal(json_string); 
+    gpr_free(sts_creds_path); 
+    GRPC_ERROR_UNREF(error); 
+    return status; 
+  }; 
+ 
+  if (sts_creds_path == nullptr) { 
+    status = grpc::Status(grpc::StatusCode::NOT_FOUND, 
+                          "STS_CREDENTIALS environment variable not set."); 
+    return cleanup(); 
+  } 
+  error = grpc_load_file(sts_creds_path, 1, &json_string); 
+  if (error != GRPC_ERROR_NONE) { 
+    status = 
+        grpc::Status(grpc::StatusCode::NOT_FOUND, grpc_error_string(error)); 
+    return cleanup(); 
+  } 
+  status = StsCredentialsOptionsFromJson( 
+      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(json_string)), 
+      options); 
+  return cleanup(); 
+} 
+ 
+// C++ to Core STS Credentials options. 
+grpc_sts_credentials_options StsCredentialsCppToCoreOptions( 
+    const StsCredentialsOptions& options) { 
+  grpc_sts_credentials_options opts; 
+  memset(&opts, 0, sizeof(opts)); 
+  opts.token_exchange_service_uri = options.token_exchange_service_uri.c_str(); 
+  opts.resource = options.resource.c_str(); 
+  opts.audience = options.audience.c_str(); 
+  opts.scope = options.scope.c_str(); 
+  opts.requested_token_type = options.requested_token_type.c_str(); 
+  opts.subject_token_path = options.subject_token_path.c_str(); 
+  opts.subject_token_type = options.subject_token_type.c_str(); 
+  opts.actor_token_path = options.actor_token_path.c_str(); 
+  opts.actor_token_type = options.actor_token_type.c_str(); 
+  return opts; 
+} 
+ 
+// Builds STS credentials. 
+std::shared_ptr<CallCredentials> StsCredentials( 
+    const StsCredentialsOptions& options) { 
+  auto opts = StsCredentialsCppToCoreOptions(options); 
+  return WrapCallCredentials(grpc_sts_credentials_create(&opts, nullptr)); 
+} 
+ 
 std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
     std::unique_ptr<MetadataCredentialsPlugin> plugin,
     grpc_security_level min_security_level) {
@@ -268,12 +268,12 @@ std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
 // Builds ALTS Credentials given ALTS specific options
 std::shared_ptr<ChannelCredentials> AltsCredentials(
     const AltsCredentialsOptions& options) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   grpc_alts_credentials_options* c_options =
       grpc_alts_credentials_client_options_create();
-  for (const auto& service_account : options.target_service_accounts) {
+  for (const auto& service_account : options.target_service_accounts) { 
     grpc_alts_credentials_client_options_add_target_service_account(
-        c_options, service_account.c_str());
+        c_options, service_account.c_str()); 
   }
   grpc_channel_credentials* c_creds = grpc_alts_credentials_create(c_options);
   grpc_alts_credentials_options_destroy(c_options);
@@ -283,22 +283,22 @@ std::shared_ptr<ChannelCredentials> AltsCredentials(
 // Builds Local Credentials
 std::shared_ptr<ChannelCredentials> LocalCredentials(
     grpc_local_connect_type type) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapChannelCredentials(grpc_local_credentials_create(type));
 }
 
-// Builds TLS Credentials given TLS options.
-std::shared_ptr<ChannelCredentials> TlsCredentials(
-    const TlsCredentialsOptions& options) {
-  return WrapChannelCredentials(
+// Builds TLS Credentials given TLS options. 
+std::shared_ptr<ChannelCredentials> TlsCredentials( 
+    const TlsCredentialsOptions& options) { 
+  return WrapChannelCredentials( 
       grpc_tls_credentials_create(options.c_credentials_options()));
-}
-
+} 
+ 
 }  // namespace experimental
 
 // Builds credentials for use when running in GCE
 std::shared_ptr<CallCredentials> GoogleComputeEngineCredentials() {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapCallCredentials(
       grpc_google_compute_engine_credentials_create(nullptr));
 }
@@ -306,7 +306,7 @@ std::shared_ptr<CallCredentials> GoogleComputeEngineCredentials() {
 // Builds JWT credentials.
 std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
     const TString& json_key, long token_lifetime_seconds) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   if (token_lifetime_seconds <= 0) {
     gpr_log(GPR_ERROR,
             "Trying to create JWTCredentials with non-positive lifetime");
@@ -321,7 +321,7 @@ std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
 // Builds refresh token credentials.
 std::shared_ptr<CallCredentials> GoogleRefreshTokenCredentials(
     const TString& json_refresh_token) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapCallCredentials(grpc_google_refresh_token_credentials_create(
       json_refresh_token.c_str(), nullptr));
 }
@@ -329,7 +329,7 @@ std::shared_ptr<CallCredentials> GoogleRefreshTokenCredentials(
 // Builds access token credentials.
 std::shared_ptr<CallCredentials> AccessTokenCredentials(
     const TString& access_token) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapCallCredentials(
       grpc_access_token_credentials_create(access_token.c_str(), nullptr));
 }
@@ -338,7 +338,7 @@ std::shared_ptr<CallCredentials> AccessTokenCredentials(
 std::shared_ptr<CallCredentials> GoogleIAMCredentials(
     const TString& authorization_token,
     const TString& authority_selector) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
   return WrapCallCredentials(grpc_google_iam_credentials_create(
       authorization_token.c_str(), authority_selector.c_str(), nullptr));
 }
@@ -374,27 +374,27 @@ std::shared_ptr<CallCredentials> CompositeCallCredentials(
   return nullptr;
 }
 
-std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin(
-    std::unique_ptr<MetadataCredentialsPlugin> plugin) {
-  grpc::GrpcLibraryCodegen init;  // To call grpc_init().
-  const char* type = plugin->GetType();
-  grpc::MetadataCredentialsPluginWrapper* wrapper =
-      new grpc::MetadataCredentialsPluginWrapper(std::move(plugin));
-  grpc_metadata_credentials_plugin c_plugin = {
-      grpc::MetadataCredentialsPluginWrapper::GetMetadata,
+std::shared_ptr<CallCredentials> MetadataCredentialsFromPlugin( 
+    std::unique_ptr<MetadataCredentialsPlugin> plugin) { 
+  grpc::GrpcLibraryCodegen init;  // To call grpc_init(). 
+  const char* type = plugin->GetType(); 
+  grpc::MetadataCredentialsPluginWrapper* wrapper = 
+      new grpc::MetadataCredentialsPluginWrapper(std::move(plugin)); 
+  grpc_metadata_credentials_plugin c_plugin = { 
+      grpc::MetadataCredentialsPluginWrapper::GetMetadata, 
       grpc::MetadataCredentialsPluginWrapper::DebugString,
-      grpc::MetadataCredentialsPluginWrapper::Destroy, wrapper, type};
+      grpc::MetadataCredentialsPluginWrapper::Destroy, wrapper, type}; 
   return WrapCallCredentials(grpc_metadata_credentials_create_from_plugin(
       c_plugin, GRPC_PRIVACY_AND_INTEGRITY, nullptr));
-}
-
-namespace {
-void DeleteWrapper(void* wrapper, grpc_error* /*ignored*/) {
+} 
+ 
+namespace { 
+void DeleteWrapper(void* wrapper, grpc_error* /*ignored*/) { 
   MetadataCredentialsPluginWrapper* w =
       static_cast<MetadataCredentialsPluginWrapper*>(wrapper);
   delete w;
 }
-}  // namespace
+}  // namespace 
 
 char* MetadataCredentialsPluginWrapper::DebugString(void* wrapper) {
   GPR_ASSERT(wrapper);
@@ -403,14 +403,14 @@ char* MetadataCredentialsPluginWrapper::DebugString(void* wrapper) {
   return gpr_strdup(w->plugin_->DebugString().c_str());
 }
 
-void MetadataCredentialsPluginWrapper::Destroy(void* wrapper) {
-  if (wrapper == nullptr) return;
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-  grpc_core::ExecCtx exec_ctx;
-  grpc_core::Executor::Run(GRPC_CLOSURE_CREATE(DeleteWrapper, wrapper, nullptr),
-                           GRPC_ERROR_NONE);
-}
-
+void MetadataCredentialsPluginWrapper::Destroy(void* wrapper) { 
+  if (wrapper == nullptr) return; 
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
+  grpc_core::ExecCtx exec_ctx; 
+  grpc_core::Executor::Run(GRPC_CLOSURE_CREATE(DeleteWrapper, wrapper, nullptr), 
+                           GRPC_ERROR_NONE); 
+} 
+ 
 int MetadataCredentialsPluginWrapper::GetMetadata(
     void* wrapper, grpc_auth_metadata_context context,
     grpc_credentials_plugin_metadata_cb cb, void* user_data,
@@ -424,18 +424,18 @@ int MetadataCredentialsPluginWrapper::GetMetadata(
     *num_creds_md = 0;
     *status = GRPC_STATUS_OK;
     *error_details = nullptr;
-    return 1;
+    return 1; 
   }
   if (w->plugin_->IsBlocking()) {
-    // The internals of context may be destroyed if GetMetadata is cancelled.
-    // Make a copy for InvokePlugin.
-    grpc_auth_metadata_context context_copy = grpc_auth_metadata_context();
-    grpc_auth_metadata_context_copy(&context, &context_copy);
+    // The internals of context may be destroyed if GetMetadata is cancelled. 
+    // Make a copy for InvokePlugin. 
+    grpc_auth_metadata_context context_copy = grpc_auth_metadata_context(); 
+    grpc_auth_metadata_context_copy(&context, &context_copy); 
     // Asynchronous return.
-    w->thread_pool_->Add([w, context_copy, cb, user_data]() mutable {
+    w->thread_pool_->Add([w, context_copy, cb, user_data]() mutable { 
       w->MetadataCredentialsPluginWrapper::InvokePlugin(
-          context_copy, cb, user_data, nullptr, nullptr, nullptr, nullptr);
-      grpc_auth_metadata_context_reset(&context_copy);
+          context_copy, cb, user_data, nullptr, nullptr, nullptr, nullptr); 
+      grpc_auth_metadata_context_reset(&context_copy); 
     });
     return 0;
   } else {
@@ -449,9 +449,9 @@ int MetadataCredentialsPluginWrapper::GetMetadata(
 namespace {
 
 void UnrefMetadata(const std::vector<grpc_metadata>& md) {
-  for (const auto& metadatum : md) {
-    grpc_slice_unref(metadatum.key);
-    grpc_slice_unref(metadatum.value);
+  for (const auto& metadatum : md) { 
+    grpc_slice_unref(metadatum.key); 
+    grpc_slice_unref(metadatum.value); 
   }
 }
 
@@ -471,10 +471,10 @@ void MetadataCredentialsPluginWrapper::InvokePlugin(
   Status status = plugin_->GetMetadata(context.service_url, context.method_name,
                                        cpp_channel_auth_context, &metadata);
   std::vector<grpc_metadata> md;
-  for (auto& metadatum : metadata) {
+  for (auto& metadatum : metadata) { 
     grpc_metadata md_entry;
-    md_entry.key = SliceFromCopiedString(metadatum.first);
-    md_entry.value = SliceFromCopiedString(metadatum.second);
+    md_entry.key = SliceFromCopiedString(metadatum.first); 
+    md_entry.value = SliceFromCopiedString(metadatum.second); 
     md_entry.flags = 0;
     md.push_back(md_entry);
   }
diff --git a/contrib/libs/grpc/src/cpp/client/secure_credentials.h b/contrib/libs/grpc/src/cpp/client/secure_credentials.h
index 4fc79346bf..16f6b9c805 100644
--- a/contrib/libs/grpc/src/cpp/client/secure_credentials.h
+++ b/contrib/libs/grpc/src/cpp/client/secure_credentials.h
@@ -22,7 +22,7 @@
 #include <grpc/grpc_security.h>
 
 #include <grpcpp/security/credentials.h>
-#include <grpcpp/security/tls_credentials_options.h>
+#include <grpcpp/security/tls_credentials_options.h> 
 #include <grpcpp/support/config.h>
 
 #include "y_absl/strings/str_cat.h"
@@ -31,8 +31,8 @@
 
 namespace grpc {
 
-class Channel;
-
+class Channel; 
+ 
 class SecureChannelCredentials final : public ChannelCredentials {
  public:
   explicit SecureChannelCredentials(grpc_channel_credentials* c_creds);
@@ -41,16 +41,16 @@ class SecureChannelCredentials final : public ChannelCredentials {
   }
   grpc_channel_credentials* GetRawCreds() { return c_creds_; }
 
-  std::shared_ptr<Channel> CreateChannelImpl(
+  std::shared_ptr<Channel> CreateChannelImpl( 
       const TString& target, const ChannelArguments& args) override;
 
   SecureChannelCredentials* AsSecureCredentials() override { return this; }
 
  private:
-  std::shared_ptr<Channel> CreateChannelWithInterceptors(
+  std::shared_ptr<Channel> CreateChannelWithInterceptors( 
       const TString& target, const ChannelArguments& args,
-      std::vector<std::unique_ptr<
-          ::grpc::experimental::ClientInterceptorFactoryInterface>>
+      std::vector<std::unique_ptr< 
+          ::grpc::experimental::ClientInterceptorFactoryInterface>> 
           interceptor_creators) override;
   grpc_channel_credentials* const c_creds_;
 };
@@ -74,16 +74,16 @@ class SecureCallCredentials final : public CallCredentials {
   grpc_call_credentials* const c_creds_;
 };
 
-namespace experimental {
-
-// Transforms C++ STS Credentials options to core options. The pointers of the
-// resulting core options point to the memory held by the C++ options so C++
-// options need to be kept alive until after the core credentials creation.
-grpc_sts_credentials_options StsCredentialsCppToCoreOptions(
-    const StsCredentialsOptions& options);
-
-}  // namespace experimental
-
+namespace experimental { 
+ 
+// Transforms C++ STS Credentials options to core options. The pointers of the 
+// resulting core options point to the memory held by the C++ options so C++ 
+// options need to be kept alive until after the core credentials creation. 
+grpc_sts_credentials_options StsCredentialsCppToCoreOptions( 
+    const StsCredentialsOptions& options); 
+ 
+}  // namespace experimental 
+ 
 class MetadataCredentialsPluginWrapper final : private GrpcLibraryCodegen {
  public:
   static void Destroy(void* wrapper);