Merge remote-tracking branch 'upstream/master' into no-authority-header-in-cronet

29 files changed, 1006 insertions, 4449 deletions

diff --git a/src/cpp/README.md b/src/cpp/README.md
index 8c0f85e5ff..d9b521317a 100644
--- a/src/cpp/README.md
+++ b/src/cpp/README.md
@@ -3,10 +3,6 @@
 
 This directory contains source code for C++ implementation of gRPC.
 
-#Status
-
-Beta
-
 #Pre-requisites
 
 ##Linux
diff --git a/src/cpp/client/channel_cc.cc b/src/cpp/client/channel_cc.cc
index 43b3875cb3..5f1d00d2b4 100644
--- a/src/cpp/client/channel_cc.cc
+++ b/src/cpp/client/channel_cc.cc
@@ -47,8 +47,8 @@
 #include <grpc++/support/status.h>
 #include <grpc++/support/time.h>
 #include <grpc/grpc.h>
+#include <grpc/slice.h>
 #include <grpc/support/log.h>
-#include <grpc/support/slice.h>
 #include "src/core/lib/profiling/timers.h"
 
 namespace grpc {
@@ -106,11 +106,11 @@ grpc_connectivity_state Channel::GetState(bool try_to_connect) {
 }
 
 namespace {
-class TagSaver GRPC_FINAL : public CompletionQueueTag {
+class TagSaver final : public CompletionQueueTag {
  public:
   explicit TagSaver(void* tag) : tag_(tag) {}
-  ~TagSaver() GRPC_OVERRIDE {}
-  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
+  ~TagSaver() override {}
+  bool FinalizeResult(void** tag, bool* status) override {
     *tag = tag_;
     delete this;
     return true;
diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc
index b6008f47b1..c073741dac 100644
--- a/src/cpp/client/client_context.cc
+++ b/src/cpp/client/client_context.cc
@@ -45,12 +45,12 @@
 
 namespace grpc {
 
-class DefaultGlobalClientCallbacks GRPC_FINAL
+class DefaultGlobalClientCallbacks final
     : public ClientContext::GlobalCallbacks {
  public:
-  ~DefaultGlobalClientCallbacks() GRPC_OVERRIDE {}
-  void DefaultConstructor(ClientContext* context) GRPC_OVERRIDE {}
-  void Destructor(ClientContext* context) GRPC_OVERRIDE {}
+  ~DefaultGlobalClientCallbacks() override {}
+  void DefaultConstructor(ClientContext* context) override {}
+  void Destructor(ClientContext* context) override {}
 };
 
 static DefaultGlobalClientCallbacks g_default_client_callbacks;
@@ -93,7 +93,7 @@ void ClientContext::AddMetadata(const grpc::string& meta_key,
 
 void ClientContext::set_call(grpc_call* call,
                              const std::shared_ptr<Channel>& channel) {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   GPR_ASSERT(call_ == nullptr);
   call_ = call;
   channel_ = channel;
@@ -119,7 +119,7 @@ void ClientContext::set_compression_algorithm(
 }
 
 void ClientContext::TryCancel() {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   if (call_) {
     grpc_call_cancel(call_, nullptr);
   } else {
diff --git a/src/cpp/client/cronet_credentials.cc b/src/cpp/client/cronet_credentials.cc
new file mode 100644
index 0000000000..8e94cf0ad7
--- /dev/null
+++ b/src/cpp/client/cronet_credentials.cc
@@ -0,0 +1,67 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc++/security/credentials.h>
+
+#include <grpc++/channel.h>
+#include <grpc++/support/channel_arguments.h>
+#include <grpc/grpc_cronet.h>
+#include "src/cpp/client/create_channel_internal.h"
+
+namespace grpc {
+
+class CronetChannelCredentialsImpl final : public ChannelCredentials {
+ public:
+  CronetChannelCredentialsImpl(void* engine) : engine_(engine) {}
+
+  std::shared_ptr<grpc::Channel> CreateChannel(
+      const string& target, const grpc::ChannelArguments& args) override {
+    grpc_channel_args channel_args;
+    args.SetChannelArgs(&channel_args);
+    return CreateChannelInternal(
+        "", grpc_cronet_secure_channel_create(engine_, target.c_str(),
+                                              &channel_args, nullptr));
+  }
+
+  SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
+
+ private:
+  void* engine_;
+};
+
+std::shared_ptr<ChannelCredentials> CronetChannelCredentials(void* engine) {
+  return std::shared_ptr<ChannelCredentials>(
+      new CronetChannelCredentialsImpl(engine));
+}
+
+}  // namespace grpc
diff --git a/src/cpp/client/insecure_credentials.cc b/src/cpp/client/insecure_credentials.cc
index 13019a7117..116f1dd4ad 100644
--- a/src/cpp/client/insecure_credentials.cc
+++ b/src/cpp/client/insecure_credentials.cc
@@ -43,10 +43,10 @@
 namespace grpc {
 
 namespace {
-class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
+class InsecureChannelCredentialsImpl final : public ChannelCredentials {
  public:
   std::shared_ptr<grpc::Channel> CreateChannel(
-      const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE {
+      const string& target, const grpc::ChannelArguments& args) override {
     grpc_channel_args channel_args;
     args.SetChannelArgs(&channel_args);
     return CreateChannelInternal(
@@ -54,9 +54,7 @@ class InsecureChannelCredentialsImpl GRPC_FINAL : public ChannelCredentials {
         grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr));
   }
 
-  SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE {
-    return nullptr;
-  }
+  SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
 };
 }  // namespace
 
diff --git a/src/cpp/client/secure_credentials.h b/src/cpp/client/secure_credentials.h
index ae41ef8007..281db17e98 100644
--- a/src/cpp/client/secure_credentials.h
+++ b/src/cpp/client/secure_credentials.h
@@ -43,34 +43,34 @@
 
 namespace grpc {
 
-class SecureChannelCredentials GRPC_FINAL : public ChannelCredentials {
+class SecureChannelCredentials final : public ChannelCredentials {
  public:
   explicit SecureChannelCredentials(grpc_channel_credentials* c_creds);
   ~SecureChannelCredentials() { grpc_channel_credentials_release(c_creds_); }
   grpc_channel_credentials* GetRawCreds() { return c_creds_; }
 
   std::shared_ptr<grpc::Channel> CreateChannel(
-      const string& target, const grpc::ChannelArguments& args) GRPC_OVERRIDE;
-  SecureChannelCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; }
+      const string& target, const grpc::ChannelArguments& args) override;
+  SecureChannelCredentials* AsSecureCredentials() override { return this; }
 
  private:
   grpc_channel_credentials* const c_creds_;
 };
 
-class SecureCallCredentials GRPC_FINAL : public CallCredentials {
+class SecureCallCredentials final : public CallCredentials {
  public:
   explicit SecureCallCredentials(grpc_call_credentials* c_creds);
   ~SecureCallCredentials() { grpc_call_credentials_release(c_creds_); }
   grpc_call_credentials* GetRawCreds() { return c_creds_; }
 
-  bool ApplyToCall(grpc_call* call) GRPC_OVERRIDE;
-  SecureCallCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; }
+  bool ApplyToCall(grpc_call* call) override;
+  SecureCallCredentials* AsSecureCredentials() override { return this; }
 
  private:
   grpc_call_credentials* const c_creds_;
 };
 
-class MetadataCredentialsPluginWrapper GRPC_FINAL {
+class MetadataCredentialsPluginWrapper final {
  public:
   static void Destroy(void* wrapper);
   static void GetMetadata(void* wrapper, grpc_auth_metadata_context context,
diff --git a/src/cpp/common/channel_arguments.cc b/src/cpp/common/channel_arguments.cc
index f297ae8587..d86ba9dd4e 100644
--- a/src/cpp/common/channel_arguments.cc
+++ b/src/cpp/common/channel_arguments.cc
@@ -34,6 +34,8 @@
 
 #include <sstream>
 
+#include <grpc++/grpc++.h>
+#include <grpc++/resource_quota.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 #include "src/core/lib/channel/channel_args.h"
@@ -41,10 +43,8 @@
 namespace grpc {
 
 ChannelArguments::ChannelArguments() {
-  std::ostringstream user_agent_prefix;
-  user_agent_prefix << "grpc-c++/" << grpc_version_string();
   // This will be ignored if used on the server side.
-  SetString(GRPC_ARG_PRIMARY_USER_AGENT_STRING, user_agent_prefix.str());
+  SetString(GRPC_ARG_PRIMARY_USER_AGENT_STRING, "grpc-c++/" + Version());
 }
 
 ChannelArguments::ChannelArguments(const ChannelArguments& other)
@@ -113,6 +113,18 @@ void ChannelArguments::SetUserAgentPrefix(
   }
 }
 
+void ChannelArguments::SetResourceQuota(
+    const grpc::ResourceQuota& resource_quota) {
+  SetPointerWithVtable(GRPC_ARG_RESOURCE_QUOTA,
+                       resource_quota.c_resource_quota(),
+                       grpc_resource_quota_arg_vtable());
+}
+
+void ChannelArguments::SetLoadBalancingPolicyName(
+    const grpc::string& lb_policy_name) {
+  SetString(GRPC_ARG_LB_POLICY_NAME, lb_policy_name);
+}
+
 void ChannelArguments::SetInt(const grpc::string& key, int value) {
   grpc_arg arg;
   arg.type = GRPC_ARG_INTEGER;
@@ -127,12 +139,18 @@ void ChannelArguments::SetPointer(const grpc::string& key, void* value) {
   static const grpc_arg_pointer_vtable vtable = {
       &PointerVtableMembers::Copy, &PointerVtableMembers::Destroy,
       &PointerVtableMembers::Compare};
+  SetPointerWithVtable(key, value, &vtable);
+}
+
+void ChannelArguments::SetPointerWithVtable(
+    const grpc::string& key, void* value,
+    const grpc_arg_pointer_vtable* vtable) {
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;
   strings_.push_back(key);
   arg.key = const_cast<char*>(strings_.back().c_str());
   arg.value.pointer.p = value;
-  arg.value.pointer.vtable = &vtable;
+  arg.value.pointer.vtable = vtable;
   args_.push_back(arg);
 }
 
diff --git a/src/cpp/common/channel_filter.cc b/src/cpp/common/channel_filter.cc
index 25cd49cb7c..ad2c0f2295 100644
--- a/src/cpp/common/channel_filter.cc
+++ b/src/cpp/common/channel_filter.cc
@@ -57,6 +57,11 @@ void ChannelData::StartTransportOp(grpc_exec_ctx *exec_ctx,
   grpc_channel_next_op(exec_ctx, elem, op->op());
 }
 
+void ChannelData::GetInfo(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+                          const grpc_channel_info *channel_info) {
+  grpc_channel_next_get_info(exec_ctx, elem, channel_info);
+}
+
 // CallData
 
 void CallData::StartTransportStreamOp(grpc_exec_ctx *exec_ctx,
diff --git a/src/cpp/common/channel_filter.h b/src/cpp/common/channel_filter.h
index ae32e02f69..e420efc71c 100644
--- a/src/cpp/common/channel_filter.h
+++ b/src/cpp/common/channel_filter.h
@@ -224,9 +224,13 @@ class ChannelData {
   const char *peer() const { return peer_; }
 
   // TODO(roth): Find a way to avoid passing elem into these methods.
+
   virtual void StartTransportOp(grpc_exec_ctx *exec_ctx,
                                 grpc_channel_element *elem, TransportOp *op);
 
+  virtual void GetInfo(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+                       const grpc_channel_info *channel_info);
+
  protected:
   /// Takes ownership of \a peer.
   ChannelData(const grpc_channel_args &args, const char *peer) : peer_(peer) {}
@@ -268,7 +272,7 @@ namespace internal {
 // Members of this class correspond to the members of the C
 // grpc_channel_filter struct.
 template <typename ChannelDataType, typename CallDataType>
-class ChannelFilter GRPC_FINAL {
+class ChannelFilter final {
  public:
   static const size_t channel_data_size = sizeof(ChannelDataType);
 
@@ -296,6 +300,13 @@ class ChannelFilter GRPC_FINAL {
     channel_data->StartTransportOp(exec_ctx, elem, &op_wrapper);
   }
 
+  static void GetChannelInfo(grpc_exec_ctx *exec_ctx,
+                             grpc_channel_element *elem,
+                             const grpc_channel_info *channel_info) {
+    ChannelDataType *channel_data = (ChannelDataType *)elem->channel_data;
+    channel_data->GetInfo(exec_ctx, elem, channel_info);
+  }
+
   static const size_t call_data_size = sizeof(CallDataType);
 
   static grpc_error *InitCallElement(grpc_exec_ctx *exec_ctx,
@@ -376,7 +387,8 @@ void RegisterChannelFilter(
        FilterType::call_data_size, FilterType::InitCallElement,
        FilterType::SetPollsetOrPollsetSet, FilterType::DestroyCallElement,
        FilterType::channel_data_size, FilterType::InitChannelElement,
-       FilterType::DestroyChannelElement, FilterType::GetPeer, name}};
+       FilterType::DestroyChannelElement, FilterType::GetPeer,
+       FilterType::GetChannelInfo, name}};
   internal::channel_filters->push_back(filter_record);
 }
 
diff --git a/src/cpp/common/core_codegen.cc b/src/cpp/common/core_codegen.cc
index ce02202976..a07ad54376 100644
--- a/src/cpp/common/core_codegen.cc
+++ b/src/cpp/common/core_codegen.cc
@@ -39,11 +39,11 @@
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
-#include <grpc/support/slice.h>
-#include <grpc/support/slice_buffer.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/profiling/timers.h"
@@ -102,31 +102,34 @@ void CoreCodegen::grpc_byte_buffer_reader_destroy(
 }
 
 int CoreCodegen::grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                              gpr_slice* slice) {
+                                              grpc_slice* slice) {
   return ::grpc_byte_buffer_reader_next(reader, slice);
 }
 
-grpc_byte_buffer* CoreCodegen::grpc_raw_byte_buffer_create(gpr_slice* slice,
+grpc_byte_buffer* CoreCodegen::grpc_raw_byte_buffer_create(grpc_slice* slice,
                                                            size_t nslices) {
   return ::grpc_raw_byte_buffer_create(slice, nslices);
 }
 
-gpr_slice CoreCodegen::gpr_slice_malloc(size_t length) {
-  return ::gpr_slice_malloc(length);
+grpc_slice CoreCodegen::grpc_slice_malloc(size_t length) {
+  return ::grpc_slice_malloc(length);
 }
 
-void CoreCodegen::gpr_slice_unref(gpr_slice slice) { ::gpr_slice_unref(slice); }
+void CoreCodegen::grpc_slice_unref(grpc_slice slice) {
+  ::grpc_slice_unref(slice);
+}
 
-gpr_slice CoreCodegen::gpr_slice_split_tail(gpr_slice* s, size_t split) {
-  return ::gpr_slice_split_tail(s, split);
+grpc_slice CoreCodegen::grpc_slice_split_tail(grpc_slice* s, size_t split) {
+  return ::grpc_slice_split_tail(s, split);
 }
 
-void CoreCodegen::gpr_slice_buffer_add(gpr_slice_buffer* sb, gpr_slice slice) {
-  ::gpr_slice_buffer_add(sb, slice);
+void CoreCodegen::grpc_slice_buffer_add(grpc_slice_buffer* sb,
+                                        grpc_slice slice) {
+  ::grpc_slice_buffer_add(sb, slice);
 }
 
-void CoreCodegen::gpr_slice_buffer_pop(gpr_slice_buffer* sb) {
-  ::gpr_slice_buffer_pop(sb);
+void CoreCodegen::grpc_slice_buffer_pop(grpc_slice_buffer* sb) {
+  ::grpc_slice_buffer_pop(sb);
 }
 
 void CoreCodegen::grpc_metadata_array_init(grpc_metadata_array* array) {
diff --git a/src/cpp/common/resource_quota_cc.cc b/src/cpp/common/resource_quota_cc.cc
new file mode 100644
index 0000000000..335896ab91
--- /dev/null
+++ b/src/cpp/common/resource_quota_cc.cc
@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc++/resource_quota.h>
+#include <grpc/grpc.h>
+
+namespace grpc {
+
+ResourceQuota::ResourceQuota() : impl_(grpc_resource_quota_create(nullptr)) {}
+
+ResourceQuota::ResourceQuota(const grpc::string& name)
+    : impl_(grpc_resource_quota_create(name.c_str())) {}
+
+ResourceQuota::~ResourceQuota() { grpc_resource_quota_unref(impl_); }
+
+ResourceQuota& ResourceQuota::Resize(size_t new_size) {
+  grpc_resource_quota_resize(impl_, new_size);
+  return *this;
+}
+
+}  // namespace grpc
diff --git a/src/cpp/common/secure_auth_context.h b/src/cpp/common/secure_auth_context.h
index c9f1dad131..98f5f09e27 100644
--- a/src/cpp/common/secure_auth_context.h
+++ b/src/cpp/common/secure_auth_context.h
@@ -40,30 +40,29 @@ struct grpc_auth_context;
 
 namespace grpc {
 
-class SecureAuthContext GRPC_FINAL : public AuthContext {
+class SecureAuthContext final : public AuthContext {
  public:
   SecureAuthContext(grpc_auth_context* ctx, bool take_ownership);
 
-  ~SecureAuthContext() GRPC_OVERRIDE;
+  ~SecureAuthContext() override;
 
-  bool IsPeerAuthenticated() const GRPC_OVERRIDE;
+  bool IsPeerAuthenticated() const override;
 
-  std::vector<grpc::string_ref> GetPeerIdentity() const GRPC_OVERRIDE;
+  std::vector<grpc::string_ref> GetPeerIdentity() const override;
 
-  grpc::string GetPeerIdentityPropertyName() const GRPC_OVERRIDE;
+  grpc::string GetPeerIdentityPropertyName() const override;
 
   std::vector<grpc::string_ref> FindPropertyValues(
-      const grpc::string& name) const GRPC_OVERRIDE;
+      const grpc::string& name) const override;
 
-  AuthPropertyIterator begin() const GRPC_OVERRIDE;
+  AuthPropertyIterator begin() const override;
 
-  AuthPropertyIterator end() const GRPC_OVERRIDE;
+  AuthPropertyIterator end() const override;
 
   void AddProperty(const grpc::string& key,
-                   const grpc::string_ref& value) GRPC_OVERRIDE;
+                   const grpc::string_ref& value) override;
 
-  virtual bool SetPeerIdentityPropertyName(const grpc::string& name)
-      GRPC_OVERRIDE;
+  virtual bool SetPeerIdentityPropertyName(const grpc::string& name) override;
 
  private:
   grpc_auth_context* ctx_;
diff --git a/src/cpp/common/version_cc.cc b/src/cpp/common/version_cc.cc
new file mode 100644
index 0000000000..7be338417f
--- /dev/null
+++ b/src/cpp/common/version_cc.cc
@@ -0,0 +1,41 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/* This file is autogenerated from:
+   templates/src/core/surface/version.c.template */
+
+#include <grpc++/grpc++.h>
+
+namespace grpc {
+grpc::string Version() { return "1.1.0-dev"; }
+}
diff --git a/src/cpp/ext/proto_server_reflection.h b/src/cpp/ext/proto_server_reflection.h
index f66f3c2c9a..ca0ba97d88 100644
--- a/src/cpp/ext/proto_server_reflection.h
+++ b/src/cpp/ext/proto_server_reflection.h
@@ -31,35 +31,18 @@
  *
  */
 
-/*
-  - If the generated header `grpc++/ext/reflection.grpc.pb.h` needs to be
-    installed, target `grpc++_reflection` in `build.yaml` should use the
-    filegroup `grpc++_reflection_proto`, and GRPC_NO_GENERATED_CODE should not
-    be defined.
-  - If the server reflection library needs to generate `reflection.grpc.pb.h`
-    from `reflection.proto` at compile time, the generated header
-    `grpc++/ext/reflection.grpc.pb.h` should not be installed. In this case,
-    target `grpc++_reflection` should depend on `grpc++_reflection_codegen`, and
-    GRPC_NO_GENERATED_CODE should be defined.
-*/
-
 #ifndef GRPC_INTERNAL_CPP_EXT_PROTO_SERVER_REFLECTION_H
 #define GRPC_INTERNAL_CPP_EXT_PROTO_SERVER_REFLECTION_H
 
 #include <unordered_set>
 #include <vector>
 
-// GRPC_NO_GENERATED_CODE indicates generated pb files should not be used
-#ifdef GRPC_NO_GENERATED_CODE
-#include "src/proto/grpc/reflection/v1alpha/reflection.grpc.pb.h"
-#else
-#include <grpc++/ext/reflection.grpc.pb.h>
-#endif  // GRPC_NO_GENERATED_CODE
 #include <grpc++/grpc++.h>
+#include "src/proto/grpc/reflection/v1alpha/reflection.grpc.pb.h"
 
 namespace grpc {
 
-class ProtoServerReflection GRPC_FINAL
+class ProtoServerReflection final
     : public reflection::v1alpha::ServerReflection::Service {
  public:
   ProtoServerReflection();
@@ -73,7 +56,7 @@ class ProtoServerReflection GRPC_FINAL
       ServerContext* context,
       ServerReaderWriter<reflection::v1alpha::ServerReflectionResponse,
                          reflection::v1alpha::ServerReflectionRequest>* stream)
-      GRPC_OVERRIDE;
+      override;
 
  private:
   Status ListService(ServerContext* context,
diff --git a/src/cpp/ext/reflection.grpc.pb.cc b/src/cpp/ext/reflection.grpc.pb.cc
deleted file mode 100644
index 8139c8ea16..0000000000
--- a/src/cpp/ext/reflection.grpc.pb.cc
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-
-// Generated by tools/codegen/extensions/gen_reflection_proto.sh
-// If you make any local change, they will be lost.
-// source: reflection.proto
-
-#include <grpc++/ext/reflection.pb.h>
-#include <grpc++/ext/reflection.grpc.pb.h>
-
-#include <grpc++/impl/codegen/async_stream.h>
-#include <grpc++/impl/codegen/async_unary_call.h>
-#include <grpc++/impl/codegen/channel_interface.h>
-#include <grpc++/impl/codegen/client_unary_call.h>
-#include <grpc++/impl/codegen/method_handler_impl.h>
-#include <grpc++/impl/codegen/rpc_service_method.h>
-#include <grpc++/impl/codegen/service_type.h>
-#include <grpc++/impl/codegen/sync_stream.h>
-namespace grpc {
-namespace reflection {
-namespace v1alpha {
-
-static const char* ServerReflection_method_names[] = {
-  "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-};
-
-std::unique_ptr< ServerReflection::Stub> ServerReflection::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
-  std::unique_ptr< ServerReflection::Stub> stub(new ServerReflection::Stub(channel));
-  return stub;
-}
-
-ServerReflection::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
-  : channel_(channel), rpcmethod_ServerReflectionInfo_(ServerReflection_method_names[0], ::grpc::RpcMethod::BIDI_STREAMING, channel)
-  {}
-
-::grpc::ClientReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* ServerReflection::Stub::ServerReflectionInfoRaw(::grpc::ClientContext* context) {
-  return new ::grpc::ClientReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>(channel_.get(), rpcmethod_ServerReflectionInfo_, context);
-}
-
-::grpc::ClientAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>* ServerReflection::Stub::AsyncServerReflectionInfoRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) {
-  return new ::grpc::ClientAsyncReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>(channel_.get(), cq, rpcmethod_ServerReflectionInfo_, context, tag);
-}
-
-ServerReflection::Service::Service() {
-  (void)ServerReflection_method_names;
-  AddMethod(new ::grpc::RpcServiceMethod(
-      ServerReflection_method_names[0],
-      ::grpc::RpcMethod::BIDI_STREAMING,
-      new ::grpc::BidiStreamingHandler< ServerReflection::Service, ::grpc::reflection::v1alpha::ServerReflectionRequest, ::grpc::reflection::v1alpha::ServerReflectionResponse>(
-          std::mem_fn(&ServerReflection::Service::ServerReflectionInfo), this)));
-}
-
-ServerReflection::Service::~Service() {
-}
-
-::grpc::Status ServerReflection::Service::ServerReflectionInfo(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::grpc::reflection::v1alpha::ServerReflectionResponse, ::grpc::reflection::v1alpha::ServerReflectionRequest>* stream) {
-  (void) context;
-  (void) stream;
-  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
-}
-
-
-}  // namespace grpc
-}  // namespace reflection
-}  // namespace v1alpha
-
diff --git a/src/cpp/ext/reflection.pb.cc b/src/cpp/ext/reflection.pb.cc
deleted file mode 100644
index d75503b3ce..0000000000
--- a/src/cpp/ext/reflection.pb.cc
+++ /dev/null
@@ -1,4045 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-
-// Generated by tools/codegen/extensions/gen_reflection_proto.sh
-// source: reflection.proto
-
-#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
-#include <grpc++/ext/reflection.pb.h>
-
-#include <algorithm>
-
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/port.h>
-#include <google/protobuf/stubs/once.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/wire_format_lite_inl.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/wire_format.h>
-// @@protoc_insertion_point(includes)
-
-namespace grpc {
-namespace reflection {
-namespace v1alpha {
-
-namespace {
-
-const ::google::protobuf::Descriptor* ServerReflectionRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ServerReflectionRequest_reflection_ = NULL;
-struct ServerReflectionRequestOneofInstance {
-  ::google::protobuf::internal::ArenaStringPtr file_by_filename_;
-  ::google::protobuf::internal::ArenaStringPtr file_containing_symbol_;
-  const ::grpc::reflection::v1alpha::ExtensionRequest* file_containing_extension_;
-  ::google::protobuf::internal::ArenaStringPtr all_extension_numbers_of_type_;
-  ::google::protobuf::internal::ArenaStringPtr list_services_;
-}* ServerReflectionRequest_default_oneof_instance_ = NULL;
-const ::google::protobuf::Descriptor* ExtensionRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ExtensionRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ServerReflectionResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ServerReflectionResponse_reflection_ = NULL;
-struct ServerReflectionResponseOneofInstance {
-  const ::grpc::reflection::v1alpha::FileDescriptorResponse* file_descriptor_response_;
-  const ::grpc::reflection::v1alpha::ExtensionNumberResponse* all_extension_numbers_response_;
-  const ::grpc::reflection::v1alpha::ListServiceResponse* list_services_response_;
-  const ::grpc::reflection::v1alpha::ErrorResponse* error_response_;
-}* ServerReflectionResponse_default_oneof_instance_ = NULL;
-const ::google::protobuf::Descriptor* FileDescriptorResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  FileDescriptorResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ExtensionNumberResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ExtensionNumberResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ListServiceResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ListServiceResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ServiceResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ServiceResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ErrorResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ErrorResponse_reflection_ = NULL;
-
-}  // namespace
-
-
-void protobuf_AssignDesc_reflection_2eproto() GOOGLE_ATTRIBUTE_COLD;
-void protobuf_AssignDesc_reflection_2eproto() {
-  protobuf_AddDesc_reflection_2eproto();
-  const ::google::protobuf::FileDescriptor* file =
-    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
-      "reflection.proto");
-  GOOGLE_CHECK(file != NULL);
-  ServerReflectionRequest_descriptor_ = file->message_type(0);
-  static const int ServerReflectionRequest_offsets_[7] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionRequest, host_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionRequest_default_oneof_instance_, file_by_filename_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionRequest_default_oneof_instance_, file_containing_symbol_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionRequest_default_oneof_instance_, file_containing_extension_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionRequest_default_oneof_instance_, all_extension_numbers_of_type_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionRequest_default_oneof_instance_, list_services_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionRequest, message_request_),
-  };
-  ServerReflectionRequest_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ServerReflectionRequest_descriptor_,
-      ServerReflectionRequest::internal_default_instance(),
-      ServerReflectionRequest_offsets_,
-      -1,
-      -1,
-      -1,
-      ServerReflectionRequest_default_oneof_instance_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionRequest, _oneof_case_[0]),
-      sizeof(ServerReflectionRequest),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionRequest, _internal_metadata_));
-  ExtensionRequest_descriptor_ = file->message_type(1);
-  static const int ExtensionRequest_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionRequest, containing_type_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionRequest, extension_number_),
-  };
-  ExtensionRequest_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ExtensionRequest_descriptor_,
-      ExtensionRequest::internal_default_instance(),
-      ExtensionRequest_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(ExtensionRequest),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionRequest, _internal_metadata_));
-  ServerReflectionResponse_descriptor_ = file->message_type(2);
-  static const int ServerReflectionResponse_offsets_[7] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionResponse, valid_host_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionResponse, original_request_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionResponse_default_oneof_instance_, file_descriptor_response_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionResponse_default_oneof_instance_, all_extension_numbers_response_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionResponse_default_oneof_instance_, list_services_response_),
-    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ServerReflectionResponse_default_oneof_instance_, error_response_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionResponse, message_response_),
-  };
-  ServerReflectionResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ServerReflectionResponse_descriptor_,
-      ServerReflectionResponse::internal_default_instance(),
-      ServerReflectionResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      ServerReflectionResponse_default_oneof_instance_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionResponse, _oneof_case_[0]),
-      sizeof(ServerReflectionResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerReflectionResponse, _internal_metadata_));
-  FileDescriptorResponse_descriptor_ = file->message_type(3);
-  static const int FileDescriptorResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorResponse, file_descriptor_proto_),
-  };
-  FileDescriptorResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      FileDescriptorResponse_descriptor_,
-      FileDescriptorResponse::internal_default_instance(),
-      FileDescriptorResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(FileDescriptorResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorResponse, _internal_metadata_));
-  ExtensionNumberResponse_descriptor_ = file->message_type(4);
-  static const int ExtensionNumberResponse_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionNumberResponse, base_type_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionNumberResponse, extension_number_),
-  };
-  ExtensionNumberResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ExtensionNumberResponse_descriptor_,
-      ExtensionNumberResponse::internal_default_instance(),
-      ExtensionNumberResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(ExtensionNumberResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExtensionNumberResponse, _internal_metadata_));
-  ListServiceResponse_descriptor_ = file->message_type(5);
-  static const int ListServiceResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListServiceResponse, service_),
-  };
-  ListServiceResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ListServiceResponse_descriptor_,
-      ListServiceResponse::internal_default_instance(),
-      ListServiceResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(ListServiceResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListServiceResponse, _internal_metadata_));
-  ServiceResponse_descriptor_ = file->message_type(6);
-  static const int ServiceResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceResponse, name_),
-  };
-  ServiceResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ServiceResponse_descriptor_,
-      ServiceResponse::internal_default_instance(),
-      ServiceResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(ServiceResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceResponse, _internal_metadata_));
-  ErrorResponse_descriptor_ = file->message_type(7);
-  static const int ErrorResponse_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorResponse, error_code_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorResponse, error_message_),
-  };
-  ErrorResponse_reflection_ =
-    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
-      ErrorResponse_descriptor_,
-      ErrorResponse::internal_default_instance(),
-      ErrorResponse_offsets_,
-      -1,
-      -1,
-      -1,
-      sizeof(ErrorResponse),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorResponse, _internal_metadata_));
-}
-
-namespace {
-
-GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
-void protobuf_AssignDescriptorsOnce() {
-  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
-                 &protobuf_AssignDesc_reflection_2eproto);
-}
-
-void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
-void protobuf_RegisterTypes(const ::std::string&) {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ServerReflectionRequest_descriptor_, ServerReflectionRequest::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ExtensionRequest_descriptor_, ExtensionRequest::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ServerReflectionResponse_descriptor_, ServerReflectionResponse::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      FileDescriptorResponse_descriptor_, FileDescriptorResponse::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ExtensionNumberResponse_descriptor_, ExtensionNumberResponse::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ListServiceResponse_descriptor_, ListServiceResponse::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ServiceResponse_descriptor_, ServiceResponse::internal_default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-      ErrorResponse_descriptor_, ErrorResponse::internal_default_instance());
-}
-
-}  // namespace
-
-void protobuf_ShutdownFile_reflection_2eproto() {
-  ServerReflectionRequest_default_instance_.Shutdown();
-  delete ServerReflectionRequest_default_oneof_instance_;
-  delete ServerReflectionRequest_reflection_;
-  ExtensionRequest_default_instance_.Shutdown();
-  delete ExtensionRequest_reflection_;
-  ServerReflectionResponse_default_instance_.Shutdown();
-  delete ServerReflectionResponse_default_oneof_instance_;
-  delete ServerReflectionResponse_reflection_;
-  FileDescriptorResponse_default_instance_.Shutdown();
-  delete FileDescriptorResponse_reflection_;
-  ExtensionNumberResponse_default_instance_.Shutdown();
-  delete ExtensionNumberResponse_reflection_;
-  ListServiceResponse_default_instance_.Shutdown();
-  delete ListServiceResponse_reflection_;
-  ServiceResponse_default_instance_.Shutdown();
-  delete ServiceResponse_reflection_;
-  ErrorResponse_default_instance_.Shutdown();
-  delete ErrorResponse_reflection_;
-}
-
-void protobuf_InitDefaults_reflection_2eproto_impl() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  ::google::protobuf::internal::GetEmptyString();
-  ServerReflectionRequest_default_instance_.DefaultConstruct();
-  ServerReflectionRequest_default_oneof_instance_ = new ServerReflectionRequestOneofInstance();
-  ::google::protobuf::internal::GetEmptyString();
-  ExtensionRequest_default_instance_.DefaultConstruct();
-  ::google::protobuf::internal::GetEmptyString();
-  ServerReflectionResponse_default_instance_.DefaultConstruct();
-  ServerReflectionResponse_default_oneof_instance_ = new ServerReflectionResponseOneofInstance();
-  ::google::protobuf::internal::GetEmptyString();
-  FileDescriptorResponse_default_instance_.DefaultConstruct();
-  ::google::protobuf::internal::GetEmptyString();
-  ExtensionNumberResponse_default_instance_.DefaultConstruct();
-  ListServiceResponse_default_instance_.DefaultConstruct();
-  ::google::protobuf::internal::GetEmptyString();
-  ServiceResponse_default_instance_.DefaultConstruct();
-  ::google::protobuf::internal::GetEmptyString();
-  ErrorResponse_default_instance_.DefaultConstruct();
-  ServerReflectionRequest_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ExtensionRequest_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ServerReflectionResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-  FileDescriptorResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ExtensionNumberResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ListServiceResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ServiceResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-  ErrorResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
-}
-
-GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_reflection_2eproto_once_);
-void protobuf_InitDefaults_reflection_2eproto() {
-  ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_reflection_2eproto_once_,
-                 &protobuf_InitDefaults_reflection_2eproto_impl);
-}
-void protobuf_AddDesc_reflection_2eproto_impl() {
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  protobuf_InitDefaults_reflection_2eproto();
-  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-    "\n\020reflection.proto\022\027grpc.reflection.v1al"
-    "pha\"\212\002\n\027ServerReflectionRequest\022\014\n\004host\030"
-    "\001 \001(\t\022\032\n\020file_by_filename\030\003 \001(\tH\000\022 \n\026fil"
-    "e_containing_symbol\030\004 \001(\tH\000\022N\n\031file_cont"
-    "aining_extension\030\005 \001(\0132).grpc.reflection"
-    ".v1alpha.ExtensionRequestH\000\022\'\n\035all_exten"
-    "sion_numbers_of_type\030\006 \001(\tH\000\022\027\n\rlist_ser"
-    "vices\030\007 \001(\tH\000B\021\n\017message_request\"E\n\020Exte"
-    "nsionRequest\022\027\n\017containing_type\030\001 \001(\t\022\030\n"
-    "\020extension_number\030\002 \001(\005\"\321\003\n\030ServerReflec"
-    "tionResponse\022\022\n\nvalid_host\030\001 \001(\t\022J\n\020orig"
-    "inal_request\030\002 \001(\01320.grpc.reflection.v1a"
-    "lpha.ServerReflectionRequest\022S\n\030file_des"
-    "criptor_response\030\004 \001(\0132/.grpc.reflection"
-    ".v1alpha.FileDescriptorResponseH\000\022Z\n\036all"
-    "_extension_numbers_response\030\005 \001(\01320.grpc"
-    ".reflection.v1alpha.ExtensionNumberRespo"
-    "nseH\000\022N\n\026list_services_response\030\006 \001(\0132,."
-    "grpc.reflection.v1alpha.ListServiceRespo"
-    "nseH\000\022@\n\016error_response\030\007 \001(\0132&.grpc.ref"
-    "lection.v1alpha.ErrorResponseH\000B\022\n\020messa"
-    "ge_response\"7\n\026FileDescriptorResponse\022\035\n"
-    "\025file_descriptor_proto\030\001 \003(\014\"K\n\027Extensio"
-    "nNumberResponse\022\026\n\016base_type_name\030\001 \001(\t\022"
-    "\030\n\020extension_number\030\002 \003(\005\"P\n\023ListService"
-    "Response\0229\n\007service\030\001 \003(\0132(.grpc.reflect"
-    "ion.v1alpha.ServiceResponse\"\037\n\017ServiceRe"
-    "sponse\022\014\n\004name\030\001 \001(\t\":\n\rErrorResponse\022\022\n"
-    "\nerror_code\030\001 \001(\005\022\025\n\rerror_message\030\002 \001(\t"
-    "2\223\001\n\020ServerReflection\022\177\n\024ServerReflectio"
-    "nInfo\0220.grpc.reflection.v1alpha.ServerRe"
-    "flectionRequest\0321.grpc.reflection.v1alph"
-    "a.ServerReflectionResponse(\0010\001b\006proto3", 1318);
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "reflection.proto", &protobuf_RegisterTypes);
-  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_reflection_2eproto);
-}
-
-GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_reflection_2eproto_once_);
-void protobuf_AddDesc_reflection_2eproto() {
-  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_reflection_2eproto_once_,
-                 &protobuf_AddDesc_reflection_2eproto_impl);
-}
-// Force AddDescriptors() to be called at static initialization time.
-struct StaticDescriptorInitializer_reflection_2eproto {
-  StaticDescriptorInitializer_reflection_2eproto() {
-    protobuf_AddDesc_reflection_2eproto();
-  }
-} static_descriptor_initializer_reflection_2eproto_;
-
-namespace {
-
-static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
-static void MergeFromFail(int line) {
-  ::google::protobuf::internal::MergeFromFail(__FILE__, line);
-}
-
-}  // namespace
-
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ServerReflectionRequest::kHostFieldNumber;
-const int ServerReflectionRequest::kFileByFilenameFieldNumber;
-const int ServerReflectionRequest::kFileContainingSymbolFieldNumber;
-const int ServerReflectionRequest::kFileContainingExtensionFieldNumber;
-const int ServerReflectionRequest::kAllExtensionNumbersOfTypeFieldNumber;
-const int ServerReflectionRequest::kListServicesFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ServerReflectionRequest::ServerReflectionRequest()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ServerReflectionRequest)
-}
-
-void ServerReflectionRequest::InitAsDefaultInstance() {
-  ServerReflectionRequest_default_oneof_instance_->file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ServerReflectionRequest_default_oneof_instance_->file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ServerReflectionRequest_default_oneof_instance_->file_containing_extension_ = const_cast< ::grpc::reflection::v1alpha::ExtensionRequest*>(
-      ::grpc::reflection::v1alpha::ExtensionRequest::internal_default_instance());
-  ServerReflectionRequest_default_oneof_instance_->all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ServerReflectionRequest_default_oneof_instance_->list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-ServerReflectionRequest::ServerReflectionRequest(const ServerReflectionRequest& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ServerReflectionRequest)
-}
-
-void ServerReflectionRequest::SharedCtor() {
-  host_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  clear_has_message_request();
-  _cached_size_ = 0;
-}
-
-ServerReflectionRequest::~ServerReflectionRequest() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ServerReflectionRequest)
-  SharedDtor();
-}
-
-void ServerReflectionRequest::SharedDtor() {
-  host_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (has_message_request()) {
-    clear_message_request();
-  }
-}
-
-void ServerReflectionRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ServerReflectionRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ServerReflectionRequest_descriptor_;
-}
-
-const ServerReflectionRequest& ServerReflectionRequest::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ServerReflectionRequest> ServerReflectionRequest_default_instance_;
-
-ServerReflectionRequest* ServerReflectionRequest::New(::google::protobuf::Arena* arena) const {
-  ServerReflectionRequest* n = new ServerReflectionRequest;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ServerReflectionRequest::clear_message_request() {
-// @@protoc_insertion_point(one_of_clear_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  switch (message_request_case()) {
-    case kFileByFilename: {
-      message_request_.file_by_filename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-      break;
-    }
-    case kFileContainingSymbol: {
-      message_request_.file_containing_symbol_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-      break;
-    }
-    case kFileContainingExtension: {
-      delete message_request_.file_containing_extension_;
-      break;
-    }
-    case kAllExtensionNumbersOfType: {
-      message_request_.all_extension_numbers_of_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-      break;
-    }
-    case kListServices: {
-      message_request_.list_services_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-      break;
-    }
-    case MESSAGE_REQUEST_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = MESSAGE_REQUEST_NOT_SET;
-}
-
-
-void ServerReflectionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  clear_message_request();
-}
-
-bool ServerReflectionRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string host = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_host()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->host().data(), this->host().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionRequest.host"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_file_by_filename;
-        break;
-      }
-
-      // optional string file_by_filename = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_file_by_filename:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_file_by_filename()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->file_by_filename().data(), this->file_by_filename().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename"));
-        } else {
-          goto handle_unusual;
-        }
-        goto after_list_services;
-        break;
-      }
-
-      // optional string file_containing_symbol = 4;
-      case 4: {
-        if (tag == 34) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_file_containing_symbol()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->file_containing_symbol().data(), this->file_containing_symbol().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol"));
-        } else {
-          goto handle_unusual;
-        }
-        goto after_list_services;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;
-      case 5: {
-        if (tag == 42) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_file_containing_extension()));
-        } else {
-          goto handle_unusual;
-        }
-        goto after_list_services;
-        break;
-      }
-
-      // optional string all_extension_numbers_of_type = 6;
-      case 6: {
-        if (tag == 50) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_all_extension_numbers_of_type()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->all_extension_numbers_of_type().data(), this->all_extension_numbers_of_type().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(58)) goto parse_list_services;
-        break;
-      }
-
-      // optional string list_services = 7;
-      case 7: {
-        if (tag == 58) {
-         parse_list_services:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_list_services()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->list_services().data(), this->list_services().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionRequest.list_services"));
-        } else {
-          goto handle_unusual;
-        }
-       after_list_services:
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ServerReflectionRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ServerReflectionRequest)
-  return false;
-#undef DO_
-}
-
-void ServerReflectionRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  // optional string host = 1;
-  if (this->host().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->host().data(), this->host().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.host");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->host(), output);
-  }
-
-  // optional string file_by_filename = 3;
-  if (has_file_by_filename()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->file_by_filename().data(), this->file_by_filename().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->file_by_filename(), output);
-  }
-
-  // optional string file_containing_symbol = 4;
-  if (has_file_containing_symbol()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->file_containing_symbol().data(), this->file_containing_symbol().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->file_containing_symbol(), output);
-  }
-
-  // optional .grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;
-  if (has_file_containing_extension()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, *message_request_.file_containing_extension_, output);
-  }
-
-  // optional string all_extension_numbers_of_type = 6;
-  if (has_all_extension_numbers_of_type()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->all_extension_numbers_of_type().data(), this->all_extension_numbers_of_type().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      6, this->all_extension_numbers_of_type(), output);
-  }
-
-  // optional string list_services = 7;
-  if (has_list_services()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->list_services().data(), this->list_services().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.list_services");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      7, this->list_services(), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ServerReflectionRequest)
-}
-
-::google::protobuf::uint8* ServerReflectionRequest::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  // optional string host = 1;
-  if (this->host().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->host().data(), this->host().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.host");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->host(), target);
-  }
-
-  // optional string file_by_filename = 3;
-  if (has_file_by_filename()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->file_by_filename().data(), this->file_by_filename().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->file_by_filename(), target);
-  }
-
-  // optional string file_containing_symbol = 4;
-  if (has_file_containing_symbol()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->file_containing_symbol().data(), this->file_containing_symbol().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->file_containing_symbol(), target);
-  }
-
-  // optional .grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;
-  if (has_file_containing_extension()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        5, *message_request_.file_containing_extension_, false, target);
-  }
-
-  // optional string all_extension_numbers_of_type = 6;
-  if (has_all_extension_numbers_of_type()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->all_extension_numbers_of_type().data(), this->all_extension_numbers_of_type().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        6, this->all_extension_numbers_of_type(), target);
-  }
-
-  // optional string list_services = 7;
-  if (has_list_services()) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->list_services().data(), this->list_services().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionRequest.list_services");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        7, this->list_services(), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ServerReflectionRequest)
-  return target;
-}
-
-size_t ServerReflectionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  size_t total_size = 0;
-
-  // optional string host = 1;
-  if (this->host().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->host());
-  }
-
-  switch (message_request_case()) {
-    // optional string file_by_filename = 3;
-    case kFileByFilename: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->file_by_filename());
-      break;
-    }
-    // optional string file_containing_symbol = 4;
-    case kFileContainingSymbol: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->file_containing_symbol());
-      break;
-    }
-    // optional .grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;
-    case kFileContainingExtension: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          *message_request_.file_containing_extension_);
-      break;
-    }
-    // optional string all_extension_numbers_of_type = 6;
-    case kAllExtensionNumbersOfType: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->all_extension_numbers_of_type());
-      break;
-    }
-    // optional string list_services = 7;
-    case kListServices: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->list_services());
-      break;
-    }
-    case MESSAGE_REQUEST_NOT_SET: {
-      break;
-    }
-  }
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ServerReflectionRequest::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ServerReflectionRequest* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ServerReflectionRequest>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ServerReflectionRequest)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ServerReflectionRequest)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ServerReflectionRequest::MergeFrom(const ServerReflectionRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ServerReflectionRequest::UnsafeMergeFrom(const ServerReflectionRequest& from) {
-  GOOGLE_DCHECK(&from != this);
-  switch (from.message_request_case()) {
-    case kFileByFilename: {
-      set_file_by_filename(from.file_by_filename());
-      break;
-    }
-    case kFileContainingSymbol: {
-      set_file_containing_symbol(from.file_containing_symbol());
-      break;
-    }
-    case kFileContainingExtension: {
-      mutable_file_containing_extension()->::grpc::reflection::v1alpha::ExtensionRequest::MergeFrom(from.file_containing_extension());
-      break;
-    }
-    case kAllExtensionNumbersOfType: {
-      set_all_extension_numbers_of_type(from.all_extension_numbers_of_type());
-      break;
-    }
-    case kListServices: {
-      set_list_services(from.list_services());
-      break;
-    }
-    case MESSAGE_REQUEST_NOT_SET: {
-      break;
-    }
-  }
-  if (from.host().size() > 0) {
-
-    host_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.host_);
-  }
-}
-
-void ServerReflectionRequest::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ServerReflectionRequest::CopyFrom(const ServerReflectionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ServerReflectionRequest)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ServerReflectionRequest::IsInitialized() const {
-
-  return true;
-}
-
-void ServerReflectionRequest::Swap(ServerReflectionRequest* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ServerReflectionRequest::InternalSwap(ServerReflectionRequest* other) {
-  host_.Swap(&other->host_);
-  std::swap(message_request_, other->message_request_);
-  std::swap(_oneof_case_[0], other->_oneof_case_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ServerReflectionRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ServerReflectionRequest_descriptor_;
-  metadata.reflection = ServerReflectionRequest_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ServerReflectionRequest
-
-// optional string host = 1;
-void ServerReflectionRequest::clear_host() {
-  host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ServerReflectionRequest::host() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-  return host_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServerReflectionRequest::set_host(const ::std::string& value) {
-  
-  host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-}
-void ServerReflectionRequest::set_host(const char* value) {
-  
-  host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-}
-void ServerReflectionRequest::set_host(const char* value, size_t size) {
-  
-  host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-}
-::std::string* ServerReflectionRequest::mutable_host() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-  return host_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionRequest::release_host() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-  
-  return host_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServerReflectionRequest::set_allocated_host(::std::string* host) {
-  if (host != NULL) {
-    
-  } else {
-    
-  }
-  host_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), host);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.host)
-}
-
-// optional string file_by_filename = 3;
-bool ServerReflectionRequest::has_file_by_filename() const {
-  return message_request_case() == kFileByFilename;
-}
-void ServerReflectionRequest::set_has_file_by_filename() {
-  _oneof_case_[0] = kFileByFilename;
-}
-void ServerReflectionRequest::clear_file_by_filename() {
-  if (has_file_by_filename()) {
-    message_request_.file_by_filename_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    clear_has_message_request();
-  }
-}
-const ::std::string& ServerReflectionRequest::file_by_filename() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-  if (has_file_by_filename()) {
-    return message_request_.file_by_filename_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-void ServerReflectionRequest::set_file_by_filename(const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-  if (!has_file_by_filename()) {
-    clear_message_request();
-    set_has_file_by_filename();
-    message_request_.file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_by_filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-}
-void ServerReflectionRequest::set_file_by_filename(const char* value) {
-  if (!has_file_by_filename()) {
-    clear_message_request();
-    set_has_file_by_filename();
-    message_request_.file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_by_filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-}
-void ServerReflectionRequest::set_file_by_filename(const char* value, size_t size) {
-  if (!has_file_by_filename()) {
-    clear_message_request();
-    set_has_file_by_filename();
-    message_request_.file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_by_filename_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-}
-::std::string* ServerReflectionRequest::mutable_file_by_filename() {
-  if (!has_file_by_filename()) {
-    clear_message_request();
-    set_has_file_by_filename();
-    message_request_.file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-  return message_request_.file_by_filename_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionRequest::release_file_by_filename() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-  if (has_file_by_filename()) {
-    clear_has_message_request();
-    return message_request_.file_by_filename_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionRequest::set_allocated_file_by_filename(::std::string* file_by_filename) {
-  if (!has_file_by_filename()) {
-    message_request_.file_by_filename_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_message_request();
-  if (file_by_filename != NULL) {
-    set_has_file_by_filename();
-    message_request_.file_by_filename_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-        file_by_filename);
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.file_by_filename)
-}
-
-// optional string file_containing_symbol = 4;
-bool ServerReflectionRequest::has_file_containing_symbol() const {
-  return message_request_case() == kFileContainingSymbol;
-}
-void ServerReflectionRequest::set_has_file_containing_symbol() {
-  _oneof_case_[0] = kFileContainingSymbol;
-}
-void ServerReflectionRequest::clear_file_containing_symbol() {
-  if (has_file_containing_symbol()) {
-    message_request_.file_containing_symbol_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    clear_has_message_request();
-  }
-}
-const ::std::string& ServerReflectionRequest::file_containing_symbol() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-  if (has_file_containing_symbol()) {
-    return message_request_.file_containing_symbol_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-void ServerReflectionRequest::set_file_containing_symbol(const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-  if (!has_file_containing_symbol()) {
-    clear_message_request();
-    set_has_file_containing_symbol();
-    message_request_.file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_containing_symbol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-}
-void ServerReflectionRequest::set_file_containing_symbol(const char* value) {
-  if (!has_file_containing_symbol()) {
-    clear_message_request();
-    set_has_file_containing_symbol();
-    message_request_.file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_containing_symbol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-}
-void ServerReflectionRequest::set_file_containing_symbol(const char* value, size_t size) {
-  if (!has_file_containing_symbol()) {
-    clear_message_request();
-    set_has_file_containing_symbol();
-    message_request_.file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.file_containing_symbol_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-}
-::std::string* ServerReflectionRequest::mutable_file_containing_symbol() {
-  if (!has_file_containing_symbol()) {
-    clear_message_request();
-    set_has_file_containing_symbol();
-    message_request_.file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-  return message_request_.file_containing_symbol_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionRequest::release_file_containing_symbol() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-  if (has_file_containing_symbol()) {
-    clear_has_message_request();
-    return message_request_.file_containing_symbol_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionRequest::set_allocated_file_containing_symbol(::std::string* file_containing_symbol) {
-  if (!has_file_containing_symbol()) {
-    message_request_.file_containing_symbol_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_message_request();
-  if (file_containing_symbol != NULL) {
-    set_has_file_containing_symbol();
-    message_request_.file_containing_symbol_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-        file_containing_symbol);
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_symbol)
-}
-
-// optional .grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;
-bool ServerReflectionRequest::has_file_containing_extension() const {
-  return message_request_case() == kFileContainingExtension;
-}
-void ServerReflectionRequest::set_has_file_containing_extension() {
-  _oneof_case_[0] = kFileContainingExtension;
-}
-void ServerReflectionRequest::clear_file_containing_extension() {
-  if (has_file_containing_extension()) {
-    delete message_request_.file_containing_extension_;
-    clear_has_message_request();
-  }
-}
- const ::grpc::reflection::v1alpha::ExtensionRequest& ServerReflectionRequest::file_containing_extension() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_extension)
-  return has_file_containing_extension()
-      ? *message_request_.file_containing_extension_
-      : ::grpc::reflection::v1alpha::ExtensionRequest::default_instance();
-}
-::grpc::reflection::v1alpha::ExtensionRequest* ServerReflectionRequest::mutable_file_containing_extension() {
-  if (!has_file_containing_extension()) {
-    clear_message_request();
-    set_has_file_containing_extension();
-    message_request_.file_containing_extension_ = new ::grpc::reflection::v1alpha::ExtensionRequest;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_extension)
-  return message_request_.file_containing_extension_;
-}
-::grpc::reflection::v1alpha::ExtensionRequest* ServerReflectionRequest::release_file_containing_extension() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_extension)
-  if (has_file_containing_extension()) {
-    clear_has_message_request();
-    ::grpc::reflection::v1alpha::ExtensionRequest* temp = message_request_.file_containing_extension_;
-    message_request_.file_containing_extension_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionRequest::set_allocated_file_containing_extension(::grpc::reflection::v1alpha::ExtensionRequest* file_containing_extension) {
-  clear_message_request();
-  if (file_containing_extension) {
-    set_has_file_containing_extension();
-    message_request_.file_containing_extension_ = file_containing_extension;
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.file_containing_extension)
-}
-
-// optional string all_extension_numbers_of_type = 6;
-bool ServerReflectionRequest::has_all_extension_numbers_of_type() const {
-  return message_request_case() == kAllExtensionNumbersOfType;
-}
-void ServerReflectionRequest::set_has_all_extension_numbers_of_type() {
-  _oneof_case_[0] = kAllExtensionNumbersOfType;
-}
-void ServerReflectionRequest::clear_all_extension_numbers_of_type() {
-  if (has_all_extension_numbers_of_type()) {
-    message_request_.all_extension_numbers_of_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    clear_has_message_request();
-  }
-}
-const ::std::string& ServerReflectionRequest::all_extension_numbers_of_type() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-  if (has_all_extension_numbers_of_type()) {
-    return message_request_.all_extension_numbers_of_type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-void ServerReflectionRequest::set_all_extension_numbers_of_type(const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-  if (!has_all_extension_numbers_of_type()) {
-    clear_message_request();
-    set_has_all_extension_numbers_of_type();
-    message_request_.all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.all_extension_numbers_of_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-}
-void ServerReflectionRequest::set_all_extension_numbers_of_type(const char* value) {
-  if (!has_all_extension_numbers_of_type()) {
-    clear_message_request();
-    set_has_all_extension_numbers_of_type();
-    message_request_.all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.all_extension_numbers_of_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-}
-void ServerReflectionRequest::set_all_extension_numbers_of_type(const char* value, size_t size) {
-  if (!has_all_extension_numbers_of_type()) {
-    clear_message_request();
-    set_has_all_extension_numbers_of_type();
-    message_request_.all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.all_extension_numbers_of_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-}
-::std::string* ServerReflectionRequest::mutable_all_extension_numbers_of_type() {
-  if (!has_all_extension_numbers_of_type()) {
-    clear_message_request();
-    set_has_all_extension_numbers_of_type();
-    message_request_.all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-  return message_request_.all_extension_numbers_of_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionRequest::release_all_extension_numbers_of_type() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-  if (has_all_extension_numbers_of_type()) {
-    clear_has_message_request();
-    return message_request_.all_extension_numbers_of_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionRequest::set_allocated_all_extension_numbers_of_type(::std::string* all_extension_numbers_of_type) {
-  if (!has_all_extension_numbers_of_type()) {
-    message_request_.all_extension_numbers_of_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_message_request();
-  if (all_extension_numbers_of_type != NULL) {
-    set_has_all_extension_numbers_of_type();
-    message_request_.all_extension_numbers_of_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-        all_extension_numbers_of_type);
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.all_extension_numbers_of_type)
-}
-
-// optional string list_services = 7;
-bool ServerReflectionRequest::has_list_services() const {
-  return message_request_case() == kListServices;
-}
-void ServerReflectionRequest::set_has_list_services() {
-  _oneof_case_[0] = kListServices;
-}
-void ServerReflectionRequest::clear_list_services() {
-  if (has_list_services()) {
-    message_request_.list_services_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    clear_has_message_request();
-  }
-}
-const ::std::string& ServerReflectionRequest::list_services() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-  if (has_list_services()) {
-    return message_request_.list_services_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-void ServerReflectionRequest::set_list_services(const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-  if (!has_list_services()) {
-    clear_message_request();
-    set_has_list_services();
-    message_request_.list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.list_services_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-}
-void ServerReflectionRequest::set_list_services(const char* value) {
-  if (!has_list_services()) {
-    clear_message_request();
-    set_has_list_services();
-    message_request_.list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.list_services_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-}
-void ServerReflectionRequest::set_list_services(const char* value, size_t size) {
-  if (!has_list_services()) {
-    clear_message_request();
-    set_has_list_services();
-    message_request_.list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  message_request_.list_services_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
-      reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-}
-::std::string* ServerReflectionRequest::mutable_list_services() {
-  if (!has_list_services()) {
-    clear_message_request();
-    set_has_list_services();
-    message_request_.list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-  return message_request_.list_services_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionRequest::release_list_services() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-  if (has_list_services()) {
-    clear_has_message_request();
-    return message_request_.list_services_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionRequest::set_allocated_list_services(::std::string* list_services) {
-  if (!has_list_services()) {
-    message_request_.list_services_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  clear_message_request();
-  if (list_services != NULL) {
-    set_has_list_services();
-    message_request_.list_services_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-        list_services);
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionRequest.list_services)
-}
-
-bool ServerReflectionRequest::has_message_request() const {
-  return message_request_case() != MESSAGE_REQUEST_NOT_SET;
-}
-void ServerReflectionRequest::clear_has_message_request() {
-  _oneof_case_[0] = MESSAGE_REQUEST_NOT_SET;
-}
-ServerReflectionRequest::MessageRequestCase ServerReflectionRequest::message_request_case() const {
-  return ServerReflectionRequest::MessageRequestCase(_oneof_case_[0]);
-}
-inline const ServerReflectionRequest* ServerReflectionRequest::internal_default_instance() {
-  return &ServerReflectionRequest_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ExtensionRequest::kContainingTypeFieldNumber;
-const int ExtensionRequest::kExtensionNumberFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ExtensionRequest::ExtensionRequest()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ExtensionRequest)
-}
-
-void ExtensionRequest::InitAsDefaultInstance() {
-}
-
-ExtensionRequest::ExtensionRequest(const ExtensionRequest& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ExtensionRequest)
-}
-
-void ExtensionRequest::SharedCtor() {
-  containing_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  extension_number_ = 0;
-  _cached_size_ = 0;
-}
-
-ExtensionRequest::~ExtensionRequest() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ExtensionRequest)
-  SharedDtor();
-}
-
-void ExtensionRequest::SharedDtor() {
-  containing_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-void ExtensionRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ExtensionRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ExtensionRequest_descriptor_;
-}
-
-const ExtensionRequest& ExtensionRequest::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ExtensionRequest> ExtensionRequest_default_instance_;
-
-ExtensionRequest* ExtensionRequest::New(::google::protobuf::Arena* arena) const {
-  ExtensionRequest* n = new ExtensionRequest;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ExtensionRequest::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ExtensionRequest)
-  containing_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  extension_number_ = 0;
-}
-
-bool ExtensionRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ExtensionRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string containing_type = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_containing_type()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->containing_type().data(), this->containing_type().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ExtensionRequest.containing_type"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_extension_number;
-        break;
-      }
-
-      // optional int32 extension_number = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_extension_number:
-
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &extension_number_)));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ExtensionRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ExtensionRequest)
-  return false;
-#undef DO_
-}
-
-void ExtensionRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ExtensionRequest)
-  // optional string containing_type = 1;
-  if (this->containing_type().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->containing_type().data(), this->containing_type().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ExtensionRequest.containing_type");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->containing_type(), output);
-  }
-
-  // optional int32 extension_number = 2;
-  if (this->extension_number() != 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->extension_number(), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ExtensionRequest)
-}
-
-::google::protobuf::uint8* ExtensionRequest::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ExtensionRequest)
-  // optional string containing_type = 1;
-  if (this->containing_type().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->containing_type().data(), this->containing_type().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ExtensionRequest.containing_type");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->containing_type(), target);
-  }
-
-  // optional int32 extension_number = 2;
-  if (this->extension_number() != 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->extension_number(), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ExtensionRequest)
-  return target;
-}
-
-size_t ExtensionRequest::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ExtensionRequest)
-  size_t total_size = 0;
-
-  // optional string containing_type = 1;
-  if (this->containing_type().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->containing_type());
-  }
-
-  // optional int32 extension_number = 2;
-  if (this->extension_number() != 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->extension_number());
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ExtensionRequest::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ExtensionRequest)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ExtensionRequest* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ExtensionRequest>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ExtensionRequest)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ExtensionRequest)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ExtensionRequest::MergeFrom(const ExtensionRequest& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ExtensionRequest)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ExtensionRequest::UnsafeMergeFrom(const ExtensionRequest& from) {
-  GOOGLE_DCHECK(&from != this);
-  if (from.containing_type().size() > 0) {
-
-    containing_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.containing_type_);
-  }
-  if (from.extension_number() != 0) {
-    set_extension_number(from.extension_number());
-  }
-}
-
-void ExtensionRequest::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ExtensionRequest)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ExtensionRequest::CopyFrom(const ExtensionRequest& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ExtensionRequest)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ExtensionRequest::IsInitialized() const {
-
-  return true;
-}
-
-void ExtensionRequest::Swap(ExtensionRequest* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ExtensionRequest::InternalSwap(ExtensionRequest* other) {
-  containing_type_.Swap(&other->containing_type_);
-  std::swap(extension_number_, other->extension_number_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ExtensionRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ExtensionRequest_descriptor_;
-  metadata.reflection = ExtensionRequest_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ExtensionRequest
-
-// optional string containing_type = 1;
-void ExtensionRequest::clear_containing_type() {
-  containing_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ExtensionRequest::containing_type() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-  return containing_type_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ExtensionRequest::set_containing_type(const ::std::string& value) {
-  
-  containing_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-}
-void ExtensionRequest::set_containing_type(const char* value) {
-  
-  containing_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-}
-void ExtensionRequest::set_containing_type(const char* value, size_t size) {
-  
-  containing_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-}
-::std::string* ExtensionRequest::mutable_containing_type() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-  return containing_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ExtensionRequest::release_containing_type() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-  
-  return containing_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ExtensionRequest::set_allocated_containing_type(::std::string* containing_type) {
-  if (containing_type != NULL) {
-    
-  } else {
-    
-  }
-  containing_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), containing_type);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ExtensionRequest.containing_type)
-}
-
-// optional int32 extension_number = 2;
-void ExtensionRequest::clear_extension_number() {
-  extension_number_ = 0;
-}
-::google::protobuf::int32 ExtensionRequest::extension_number() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ExtensionRequest.extension_number)
-  return extension_number_;
-}
-void ExtensionRequest::set_extension_number(::google::protobuf::int32 value) {
-  
-  extension_number_ = value;
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ExtensionRequest.extension_number)
-}
-
-inline const ExtensionRequest* ExtensionRequest::internal_default_instance() {
-  return &ExtensionRequest_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ServerReflectionResponse::kValidHostFieldNumber;
-const int ServerReflectionResponse::kOriginalRequestFieldNumber;
-const int ServerReflectionResponse::kFileDescriptorResponseFieldNumber;
-const int ServerReflectionResponse::kAllExtensionNumbersResponseFieldNumber;
-const int ServerReflectionResponse::kListServicesResponseFieldNumber;
-const int ServerReflectionResponse::kErrorResponseFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ServerReflectionResponse::ServerReflectionResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ServerReflectionResponse)
-}
-
-void ServerReflectionResponse::InitAsDefaultInstance() {
-  original_request_ = const_cast< ::grpc::reflection::v1alpha::ServerReflectionRequest*>(
-      ::grpc::reflection::v1alpha::ServerReflectionRequest::internal_default_instance());
-  ServerReflectionResponse_default_oneof_instance_->file_descriptor_response_ = const_cast< ::grpc::reflection::v1alpha::FileDescriptorResponse*>(
-      ::grpc::reflection::v1alpha::FileDescriptorResponse::internal_default_instance());
-  ServerReflectionResponse_default_oneof_instance_->all_extension_numbers_response_ = const_cast< ::grpc::reflection::v1alpha::ExtensionNumberResponse*>(
-      ::grpc::reflection::v1alpha::ExtensionNumberResponse::internal_default_instance());
-  ServerReflectionResponse_default_oneof_instance_->list_services_response_ = const_cast< ::grpc::reflection::v1alpha::ListServiceResponse*>(
-      ::grpc::reflection::v1alpha::ListServiceResponse::internal_default_instance());
-  ServerReflectionResponse_default_oneof_instance_->error_response_ = const_cast< ::grpc::reflection::v1alpha::ErrorResponse*>(
-      ::grpc::reflection::v1alpha::ErrorResponse::internal_default_instance());
-}
-
-ServerReflectionResponse::ServerReflectionResponse(const ServerReflectionResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ServerReflectionResponse)
-}
-
-void ServerReflectionResponse::SharedCtor() {
-  valid_host_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  original_request_ = NULL;
-  clear_has_message_response();
-  _cached_size_ = 0;
-}
-
-ServerReflectionResponse::~ServerReflectionResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ServerReflectionResponse)
-  SharedDtor();
-}
-
-void ServerReflectionResponse::SharedDtor() {
-  valid_host_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (has_message_response()) {
-    clear_message_response();
-  }
-  if (this != &ServerReflectionResponse_default_instance_.get()) {
-    delete original_request_;
-  }
-}
-
-void ServerReflectionResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ServerReflectionResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ServerReflectionResponse_descriptor_;
-}
-
-const ServerReflectionResponse& ServerReflectionResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ServerReflectionResponse> ServerReflectionResponse_default_instance_;
-
-ServerReflectionResponse* ServerReflectionResponse::New(::google::protobuf::Arena* arena) const {
-  ServerReflectionResponse* n = new ServerReflectionResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ServerReflectionResponse::clear_message_response() {
-// @@protoc_insertion_point(one_of_clear_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  switch (message_response_case()) {
-    case kFileDescriptorResponse: {
-      delete message_response_.file_descriptor_response_;
-      break;
-    }
-    case kAllExtensionNumbersResponse: {
-      delete message_response_.all_extension_numbers_response_;
-      break;
-    }
-    case kListServicesResponse: {
-      delete message_response_.list_services_response_;
-      break;
-    }
-    case kErrorResponse: {
-      delete message_response_.error_response_;
-      break;
-    }
-    case MESSAGE_RESPONSE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = MESSAGE_RESPONSE_NOT_SET;
-}
-
-
-void ServerReflectionResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  valid_host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  if (GetArenaNoVirtual() == NULL && original_request_ != NULL) delete original_request_;
-  original_request_ = NULL;
-  clear_message_response();
-}
-
-bool ServerReflectionResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string valid_host = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_valid_host()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->valid_host().data(), this->valid_host().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServerReflectionResponse.valid_host"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_original_request;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_original_request:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_original_request()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_file_descriptor_response;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_file_descriptor_response:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_file_descriptor_response()));
-        } else {
-          goto handle_unusual;
-        }
-        goto after_error_response;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;
-      case 5: {
-        if (tag == 42) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_all_extension_numbers_response()));
-        } else {
-          goto handle_unusual;
-        }
-        goto after_error_response;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;
-      case 6: {
-        if (tag == 50) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_list_services_response()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(58)) goto parse_error_response;
-        break;
-      }
-
-      // optional .grpc.reflection.v1alpha.ErrorResponse error_response = 7;
-      case 7: {
-        if (tag == 58) {
-         parse_error_response:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_error_response()));
-        } else {
-          goto handle_unusual;
-        }
-       after_error_response:
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ServerReflectionResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ServerReflectionResponse)
-  return false;
-#undef DO_
-}
-
-void ServerReflectionResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  // optional string valid_host = 1;
-  if (this->valid_host().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->valid_host().data(), this->valid_host().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionResponse.valid_host");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->valid_host(), output);
-  }
-
-  // optional .grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;
-  if (this->has_original_request()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, *this->original_request_, output);
-  }
-
-  // optional .grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;
-  if (has_file_descriptor_response()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, *message_response_.file_descriptor_response_, output);
-  }
-
-  // optional .grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;
-  if (has_all_extension_numbers_response()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, *message_response_.all_extension_numbers_response_, output);
-  }
-
-  // optional .grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;
-  if (has_list_services_response()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, *message_response_.list_services_response_, output);
-  }
-
-  // optional .grpc.reflection.v1alpha.ErrorResponse error_response = 7;
-  if (has_error_response()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      7, *message_response_.error_response_, output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ServerReflectionResponse)
-}
-
-::google::protobuf::uint8* ServerReflectionResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  // optional string valid_host = 1;
-  if (this->valid_host().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->valid_host().data(), this->valid_host().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServerReflectionResponse.valid_host");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->valid_host(), target);
-  }
-
-  // optional .grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;
-  if (this->has_original_request()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        2, *this->original_request_, false, target);
-  }
-
-  // optional .grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;
-  if (has_file_descriptor_response()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        4, *message_response_.file_descriptor_response_, false, target);
-  }
-
-  // optional .grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;
-  if (has_all_extension_numbers_response()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        5, *message_response_.all_extension_numbers_response_, false, target);
-  }
-
-  // optional .grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;
-  if (has_list_services_response()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        6, *message_response_.list_services_response_, false, target);
-  }
-
-  // optional .grpc.reflection.v1alpha.ErrorResponse error_response = 7;
-  if (has_error_response()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        7, *message_response_.error_response_, false, target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ServerReflectionResponse)
-  return target;
-}
-
-size_t ServerReflectionResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  size_t total_size = 0;
-
-  // optional string valid_host = 1;
-  if (this->valid_host().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->valid_host());
-  }
-
-  // optional .grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;
-  if (this->has_original_request()) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        *this->original_request_);
-  }
-
-  switch (message_response_case()) {
-    // optional .grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;
-    case kFileDescriptorResponse: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          *message_response_.file_descriptor_response_);
-      break;
-    }
-    // optional .grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;
-    case kAllExtensionNumbersResponse: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          *message_response_.all_extension_numbers_response_);
-      break;
-    }
-    // optional .grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;
-    case kListServicesResponse: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          *message_response_.list_services_response_);
-      break;
-    }
-    // optional .grpc.reflection.v1alpha.ErrorResponse error_response = 7;
-    case kErrorResponse: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          *message_response_.error_response_);
-      break;
-    }
-    case MESSAGE_RESPONSE_NOT_SET: {
-      break;
-    }
-  }
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ServerReflectionResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ServerReflectionResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ServerReflectionResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ServerReflectionResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ServerReflectionResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ServerReflectionResponse::MergeFrom(const ServerReflectionResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ServerReflectionResponse::UnsafeMergeFrom(const ServerReflectionResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  switch (from.message_response_case()) {
-    case kFileDescriptorResponse: {
-      mutable_file_descriptor_response()->::grpc::reflection::v1alpha::FileDescriptorResponse::MergeFrom(from.file_descriptor_response());
-      break;
-    }
-    case kAllExtensionNumbersResponse: {
-      mutable_all_extension_numbers_response()->::grpc::reflection::v1alpha::ExtensionNumberResponse::MergeFrom(from.all_extension_numbers_response());
-      break;
-    }
-    case kListServicesResponse: {
-      mutable_list_services_response()->::grpc::reflection::v1alpha::ListServiceResponse::MergeFrom(from.list_services_response());
-      break;
-    }
-    case kErrorResponse: {
-      mutable_error_response()->::grpc::reflection::v1alpha::ErrorResponse::MergeFrom(from.error_response());
-      break;
-    }
-    case MESSAGE_RESPONSE_NOT_SET: {
-      break;
-    }
-  }
-  if (from.valid_host().size() > 0) {
-
-    valid_host_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.valid_host_);
-  }
-  if (from.has_original_request()) {
-    mutable_original_request()->::grpc::reflection::v1alpha::ServerReflectionRequest::MergeFrom(from.original_request());
-  }
-}
-
-void ServerReflectionResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ServerReflectionResponse::CopyFrom(const ServerReflectionResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ServerReflectionResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ServerReflectionResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ServerReflectionResponse::Swap(ServerReflectionResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ServerReflectionResponse::InternalSwap(ServerReflectionResponse* other) {
-  valid_host_.Swap(&other->valid_host_);
-  std::swap(original_request_, other->original_request_);
-  std::swap(message_response_, other->message_response_);
-  std::swap(_oneof_case_[0], other->_oneof_case_[0]);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ServerReflectionResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ServerReflectionResponse_descriptor_;
-  metadata.reflection = ServerReflectionResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ServerReflectionResponse
-
-// optional string valid_host = 1;
-void ServerReflectionResponse::clear_valid_host() {
-  valid_host_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ServerReflectionResponse::valid_host() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-  return valid_host_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServerReflectionResponse::set_valid_host(const ::std::string& value) {
-  
-  valid_host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-}
-void ServerReflectionResponse::set_valid_host(const char* value) {
-  
-  valid_host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-}
-void ServerReflectionResponse::set_valid_host(const char* value, size_t size) {
-  
-  valid_host_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-}
-::std::string* ServerReflectionResponse::mutable_valid_host() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-  return valid_host_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServerReflectionResponse::release_valid_host() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-  
-  return valid_host_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServerReflectionResponse::set_allocated_valid_host(::std::string* valid_host) {
-  if (valid_host != NULL) {
-    
-  } else {
-    
-  }
-  valid_host_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), valid_host);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.valid_host)
-}
-
-// optional .grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;
-bool ServerReflectionResponse::has_original_request() const {
-  return this != internal_default_instance() && original_request_ != NULL;
-}
-void ServerReflectionResponse::clear_original_request() {
-  if (GetArenaNoVirtual() == NULL && original_request_ != NULL) delete original_request_;
-  original_request_ = NULL;
-}
-const ::grpc::reflection::v1alpha::ServerReflectionRequest& ServerReflectionResponse::original_request() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.original_request)
-  return original_request_ != NULL ? *original_request_
-                         : *::grpc::reflection::v1alpha::ServerReflectionRequest::internal_default_instance();
-}
-::grpc::reflection::v1alpha::ServerReflectionRequest* ServerReflectionResponse::mutable_original_request() {
-  
-  if (original_request_ == NULL) {
-    original_request_ = new ::grpc::reflection::v1alpha::ServerReflectionRequest;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.original_request)
-  return original_request_;
-}
-::grpc::reflection::v1alpha::ServerReflectionRequest* ServerReflectionResponse::release_original_request() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.original_request)
-  
-  ::grpc::reflection::v1alpha::ServerReflectionRequest* temp = original_request_;
-  original_request_ = NULL;
-  return temp;
-}
-void ServerReflectionResponse::set_allocated_original_request(::grpc::reflection::v1alpha::ServerReflectionRequest* original_request) {
-  delete original_request_;
-  original_request_ = original_request;
-  if (original_request) {
-    
-  } else {
-    
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.original_request)
-}
-
-// optional .grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;
-bool ServerReflectionResponse::has_file_descriptor_response() const {
-  return message_response_case() == kFileDescriptorResponse;
-}
-void ServerReflectionResponse::set_has_file_descriptor_response() {
-  _oneof_case_[0] = kFileDescriptorResponse;
-}
-void ServerReflectionResponse::clear_file_descriptor_response() {
-  if (has_file_descriptor_response()) {
-    delete message_response_.file_descriptor_response_;
-    clear_has_message_response();
-  }
-}
- const ::grpc::reflection::v1alpha::FileDescriptorResponse& ServerReflectionResponse::file_descriptor_response() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.file_descriptor_response)
-  return has_file_descriptor_response()
-      ? *message_response_.file_descriptor_response_
-      : ::grpc::reflection::v1alpha::FileDescriptorResponse::default_instance();
-}
-::grpc::reflection::v1alpha::FileDescriptorResponse* ServerReflectionResponse::mutable_file_descriptor_response() {
-  if (!has_file_descriptor_response()) {
-    clear_message_response();
-    set_has_file_descriptor_response();
-    message_response_.file_descriptor_response_ = new ::grpc::reflection::v1alpha::FileDescriptorResponse;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.file_descriptor_response)
-  return message_response_.file_descriptor_response_;
-}
-::grpc::reflection::v1alpha::FileDescriptorResponse* ServerReflectionResponse::release_file_descriptor_response() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.file_descriptor_response)
-  if (has_file_descriptor_response()) {
-    clear_has_message_response();
-    ::grpc::reflection::v1alpha::FileDescriptorResponse* temp = message_response_.file_descriptor_response_;
-    message_response_.file_descriptor_response_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionResponse::set_allocated_file_descriptor_response(::grpc::reflection::v1alpha::FileDescriptorResponse* file_descriptor_response) {
-  clear_message_response();
-  if (file_descriptor_response) {
-    set_has_file_descriptor_response();
-    message_response_.file_descriptor_response_ = file_descriptor_response;
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.file_descriptor_response)
-}
-
-// optional .grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;
-bool ServerReflectionResponse::has_all_extension_numbers_response() const {
-  return message_response_case() == kAllExtensionNumbersResponse;
-}
-void ServerReflectionResponse::set_has_all_extension_numbers_response() {
-  _oneof_case_[0] = kAllExtensionNumbersResponse;
-}
-void ServerReflectionResponse::clear_all_extension_numbers_response() {
-  if (has_all_extension_numbers_response()) {
-    delete message_response_.all_extension_numbers_response_;
-    clear_has_message_response();
-  }
-}
- const ::grpc::reflection::v1alpha::ExtensionNumberResponse& ServerReflectionResponse::all_extension_numbers_response() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.all_extension_numbers_response)
-  return has_all_extension_numbers_response()
-      ? *message_response_.all_extension_numbers_response_
-      : ::grpc::reflection::v1alpha::ExtensionNumberResponse::default_instance();
-}
-::grpc::reflection::v1alpha::ExtensionNumberResponse* ServerReflectionResponse::mutable_all_extension_numbers_response() {
-  if (!has_all_extension_numbers_response()) {
-    clear_message_response();
-    set_has_all_extension_numbers_response();
-    message_response_.all_extension_numbers_response_ = new ::grpc::reflection::v1alpha::ExtensionNumberResponse;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.all_extension_numbers_response)
-  return message_response_.all_extension_numbers_response_;
-}
-::grpc::reflection::v1alpha::ExtensionNumberResponse* ServerReflectionResponse::release_all_extension_numbers_response() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.all_extension_numbers_response)
-  if (has_all_extension_numbers_response()) {
-    clear_has_message_response();
-    ::grpc::reflection::v1alpha::ExtensionNumberResponse* temp = message_response_.all_extension_numbers_response_;
-    message_response_.all_extension_numbers_response_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionResponse::set_allocated_all_extension_numbers_response(::grpc::reflection::v1alpha::ExtensionNumberResponse* all_extension_numbers_response) {
-  clear_message_response();
-  if (all_extension_numbers_response) {
-    set_has_all_extension_numbers_response();
-    message_response_.all_extension_numbers_response_ = all_extension_numbers_response;
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.all_extension_numbers_response)
-}
-
-// optional .grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;
-bool ServerReflectionResponse::has_list_services_response() const {
-  return message_response_case() == kListServicesResponse;
-}
-void ServerReflectionResponse::set_has_list_services_response() {
-  _oneof_case_[0] = kListServicesResponse;
-}
-void ServerReflectionResponse::clear_list_services_response() {
-  if (has_list_services_response()) {
-    delete message_response_.list_services_response_;
-    clear_has_message_response();
-  }
-}
- const ::grpc::reflection::v1alpha::ListServiceResponse& ServerReflectionResponse::list_services_response() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.list_services_response)
-  return has_list_services_response()
-      ? *message_response_.list_services_response_
-      : ::grpc::reflection::v1alpha::ListServiceResponse::default_instance();
-}
-::grpc::reflection::v1alpha::ListServiceResponse* ServerReflectionResponse::mutable_list_services_response() {
-  if (!has_list_services_response()) {
-    clear_message_response();
-    set_has_list_services_response();
-    message_response_.list_services_response_ = new ::grpc::reflection::v1alpha::ListServiceResponse;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.list_services_response)
-  return message_response_.list_services_response_;
-}
-::grpc::reflection::v1alpha::ListServiceResponse* ServerReflectionResponse::release_list_services_response() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.list_services_response)
-  if (has_list_services_response()) {
-    clear_has_message_response();
-    ::grpc::reflection::v1alpha::ListServiceResponse* temp = message_response_.list_services_response_;
-    message_response_.list_services_response_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionResponse::set_allocated_list_services_response(::grpc::reflection::v1alpha::ListServiceResponse* list_services_response) {
-  clear_message_response();
-  if (list_services_response) {
-    set_has_list_services_response();
-    message_response_.list_services_response_ = list_services_response;
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.list_services_response)
-}
-
-// optional .grpc.reflection.v1alpha.ErrorResponse error_response = 7;
-bool ServerReflectionResponse::has_error_response() const {
-  return message_response_case() == kErrorResponse;
-}
-void ServerReflectionResponse::set_has_error_response() {
-  _oneof_case_[0] = kErrorResponse;
-}
-void ServerReflectionResponse::clear_error_response() {
-  if (has_error_response()) {
-    delete message_response_.error_response_;
-    clear_has_message_response();
-  }
-}
- const ::grpc::reflection::v1alpha::ErrorResponse& ServerReflectionResponse::error_response() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServerReflectionResponse.error_response)
-  return has_error_response()
-      ? *message_response_.error_response_
-      : ::grpc::reflection::v1alpha::ErrorResponse::default_instance();
-}
-::grpc::reflection::v1alpha::ErrorResponse* ServerReflectionResponse::mutable_error_response() {
-  if (!has_error_response()) {
-    clear_message_response();
-    set_has_error_response();
-    message_response_.error_response_ = new ::grpc::reflection::v1alpha::ErrorResponse;
-  }
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServerReflectionResponse.error_response)
-  return message_response_.error_response_;
-}
-::grpc::reflection::v1alpha::ErrorResponse* ServerReflectionResponse::release_error_response() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServerReflectionResponse.error_response)
-  if (has_error_response()) {
-    clear_has_message_response();
-    ::grpc::reflection::v1alpha::ErrorResponse* temp = message_response_.error_response_;
-    message_response_.error_response_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
-}
-void ServerReflectionResponse::set_allocated_error_response(::grpc::reflection::v1alpha::ErrorResponse* error_response) {
-  clear_message_response();
-  if (error_response) {
-    set_has_error_response();
-    message_response_.error_response_ = error_response;
-  }
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServerReflectionResponse.error_response)
-}
-
-bool ServerReflectionResponse::has_message_response() const {
-  return message_response_case() != MESSAGE_RESPONSE_NOT_SET;
-}
-void ServerReflectionResponse::clear_has_message_response() {
-  _oneof_case_[0] = MESSAGE_RESPONSE_NOT_SET;
-}
-ServerReflectionResponse::MessageResponseCase ServerReflectionResponse::message_response_case() const {
-  return ServerReflectionResponse::MessageResponseCase(_oneof_case_[0]);
-}
-inline const ServerReflectionResponse* ServerReflectionResponse::internal_default_instance() {
-  return &ServerReflectionResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int FileDescriptorResponse::kFileDescriptorProtoFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-FileDescriptorResponse::FileDescriptorResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.FileDescriptorResponse)
-}
-
-void FileDescriptorResponse::InitAsDefaultInstance() {
-}
-
-FileDescriptorResponse::FileDescriptorResponse(const FileDescriptorResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.FileDescriptorResponse)
-}
-
-void FileDescriptorResponse::SharedCtor() {
-  _cached_size_ = 0;
-}
-
-FileDescriptorResponse::~FileDescriptorResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.FileDescriptorResponse)
-  SharedDtor();
-}
-
-void FileDescriptorResponse::SharedDtor() {
-}
-
-void FileDescriptorResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* FileDescriptorResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return FileDescriptorResponse_descriptor_;
-}
-
-const FileDescriptorResponse& FileDescriptorResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<FileDescriptorResponse> FileDescriptorResponse_default_instance_;
-
-FileDescriptorResponse* FileDescriptorResponse::New(::google::protobuf::Arena* arena) const {
-  FileDescriptorResponse* n = new FileDescriptorResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void FileDescriptorResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  file_descriptor_proto_.Clear();
-}
-
-bool FileDescriptorResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated bytes file_descriptor_proto = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_file_descriptor_proto:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->add_file_descriptor_proto()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_file_descriptor_proto;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.FileDescriptorResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.FileDescriptorResponse)
-  return false;
-#undef DO_
-}
-
-void FileDescriptorResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  // repeated bytes file_descriptor_proto = 1;
-  for (int i = 0; i < this->file_descriptor_proto_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytes(
-      1, this->file_descriptor_proto(i), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.FileDescriptorResponse)
-}
-
-::google::protobuf::uint8* FileDescriptorResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  // repeated bytes file_descriptor_proto = 1;
-  for (int i = 0; i < this->file_descriptor_proto_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteBytesToArray(1, this->file_descriptor_proto(i), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.FileDescriptorResponse)
-  return target;
-}
-
-size_t FileDescriptorResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  size_t total_size = 0;
-
-  // repeated bytes file_descriptor_proto = 1;
-  total_size += 1 *
-      ::google::protobuf::internal::FromIntSize(this->file_descriptor_proto_size());
-  for (int i = 0; i < this->file_descriptor_proto_size(); i++) {
-    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
-      this->file_descriptor_proto(i));
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void FileDescriptorResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const FileDescriptorResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const FileDescriptorResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.FileDescriptorResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.FileDescriptorResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void FileDescriptorResponse::MergeFrom(const FileDescriptorResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void FileDescriptorResponse::UnsafeMergeFrom(const FileDescriptorResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  file_descriptor_proto_.UnsafeMergeFrom(from.file_descriptor_proto_);
-}
-
-void FileDescriptorResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void FileDescriptorResponse::CopyFrom(const FileDescriptorResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.FileDescriptorResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool FileDescriptorResponse::IsInitialized() const {
-
-  return true;
-}
-
-void FileDescriptorResponse::Swap(FileDescriptorResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void FileDescriptorResponse::InternalSwap(FileDescriptorResponse* other) {
-  file_descriptor_proto_.UnsafeArenaSwap(&other->file_descriptor_proto_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata FileDescriptorResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = FileDescriptorResponse_descriptor_;
-  metadata.reflection = FileDescriptorResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// FileDescriptorResponse
-
-// repeated bytes file_descriptor_proto = 1;
-int FileDescriptorResponse::file_descriptor_proto_size() const {
-  return file_descriptor_proto_.size();
-}
-void FileDescriptorResponse::clear_file_descriptor_proto() {
-  file_descriptor_proto_.Clear();
-}
-const ::std::string& FileDescriptorResponse::file_descriptor_proto(int index) const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  return file_descriptor_proto_.Get(index);
-}
-::std::string* FileDescriptorResponse::mutable_file_descriptor_proto(int index) {
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  return file_descriptor_proto_.Mutable(index);
-}
-void FileDescriptorResponse::set_file_descriptor_proto(int index, const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  file_descriptor_proto_.Mutable(index)->assign(value);
-}
-void FileDescriptorResponse::set_file_descriptor_proto(int index, const char* value) {
-  file_descriptor_proto_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-}
-void FileDescriptorResponse::set_file_descriptor_proto(int index, const void* value, size_t size) {
-  file_descriptor_proto_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-}
-::std::string* FileDescriptorResponse::add_file_descriptor_proto() {
-  // @@protoc_insertion_point(field_add_mutable:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  return file_descriptor_proto_.Add();
-}
-void FileDescriptorResponse::add_file_descriptor_proto(const ::std::string& value) {
-  file_descriptor_proto_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-}
-void FileDescriptorResponse::add_file_descriptor_proto(const char* value) {
-  file_descriptor_proto_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-}
-void FileDescriptorResponse::add_file_descriptor_proto(const void* value, size_t size) {
-  file_descriptor_proto_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-}
-const ::google::protobuf::RepeatedPtrField< ::std::string>&
-FileDescriptorResponse::file_descriptor_proto() const {
-  // @@protoc_insertion_point(field_list:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  return file_descriptor_proto_;
-}
-::google::protobuf::RepeatedPtrField< ::std::string>*
-FileDescriptorResponse::mutable_file_descriptor_proto() {
-  // @@protoc_insertion_point(field_mutable_list:grpc.reflection.v1alpha.FileDescriptorResponse.file_descriptor_proto)
-  return &file_descriptor_proto_;
-}
-
-inline const FileDescriptorResponse* FileDescriptorResponse::internal_default_instance() {
-  return &FileDescriptorResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ExtensionNumberResponse::kBaseTypeNameFieldNumber;
-const int ExtensionNumberResponse::kExtensionNumberFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ExtensionNumberResponse::ExtensionNumberResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ExtensionNumberResponse)
-}
-
-void ExtensionNumberResponse::InitAsDefaultInstance() {
-}
-
-ExtensionNumberResponse::ExtensionNumberResponse(const ExtensionNumberResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ExtensionNumberResponse)
-}
-
-void ExtensionNumberResponse::SharedCtor() {
-  base_type_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  _cached_size_ = 0;
-}
-
-ExtensionNumberResponse::~ExtensionNumberResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  SharedDtor();
-}
-
-void ExtensionNumberResponse::SharedDtor() {
-  base_type_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-void ExtensionNumberResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ExtensionNumberResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ExtensionNumberResponse_descriptor_;
-}
-
-const ExtensionNumberResponse& ExtensionNumberResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ExtensionNumberResponse> ExtensionNumberResponse_default_instance_;
-
-ExtensionNumberResponse* ExtensionNumberResponse::New(::google::protobuf::Arena* arena) const {
-  ExtensionNumberResponse* n = new ExtensionNumberResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ExtensionNumberResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  base_type_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  extension_number_.Clear();
-}
-
-bool ExtensionNumberResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string base_type_name = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_base_type_name()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->base_type_name().data(), this->base_type_name().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_extension_number;
-        break;
-      }
-
-      // repeated int32 extension_number = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_extension_number:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, this->mutable_extension_number())));
-        } else if (tag == 16) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 1, 18, input, this->mutable_extension_number())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  return false;
-#undef DO_
-}
-
-void ExtensionNumberResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  // optional string base_type_name = 1;
-  if (this->base_type_name().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->base_type_name().data(), this->base_type_name().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->base_type_name(), output);
-  }
-
-  // repeated int32 extension_number = 2;
-  if (this->extension_number_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_extension_number_cached_byte_size_);
-  }
-  for (int i = 0; i < this->extension_number_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
-      this->extension_number(i), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ExtensionNumberResponse)
-}
-
-::google::protobuf::uint8* ExtensionNumberResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  // optional string base_type_name = 1;
-  if (this->base_type_name().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->base_type_name().data(), this->base_type_name().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->base_type_name(), target);
-  }
-
-  // repeated int32 extension_number = 2;
-  if (this->extension_number_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      2,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _extension_number_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->extension_number_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteInt32NoTagToArray(this->extension_number(i), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  return target;
-}
-
-size_t ExtensionNumberResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  size_t total_size = 0;
-
-  // optional string base_type_name = 1;
-  if (this->base_type_name().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->base_type_name());
-  }
-
-  // repeated int32 extension_number = 2;
-  {
-    size_t data_size = 0;
-    unsigned int count = this->extension_number_size();
-    for (unsigned int i = 0; i < count; i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        Int32Size(this->extension_number(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _extension_number_cached_byte_size_ = cached_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ExtensionNumberResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ExtensionNumberResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ExtensionNumberResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ExtensionNumberResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ExtensionNumberResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ExtensionNumberResponse::MergeFrom(const ExtensionNumberResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ExtensionNumberResponse::UnsafeMergeFrom(const ExtensionNumberResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  extension_number_.UnsafeMergeFrom(from.extension_number_);
-  if (from.base_type_name().size() > 0) {
-
-    base_type_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.base_type_name_);
-  }
-}
-
-void ExtensionNumberResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ExtensionNumberResponse::CopyFrom(const ExtensionNumberResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ExtensionNumberResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ExtensionNumberResponse::Swap(ExtensionNumberResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ExtensionNumberResponse::InternalSwap(ExtensionNumberResponse* other) {
-  base_type_name_.Swap(&other->base_type_name_);
-  extension_number_.UnsafeArenaSwap(&other->extension_number_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ExtensionNumberResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ExtensionNumberResponse_descriptor_;
-  metadata.reflection = ExtensionNumberResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ExtensionNumberResponse
-
-// optional string base_type_name = 1;
-void ExtensionNumberResponse::clear_base_type_name() {
-  base_type_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ExtensionNumberResponse::base_type_name() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-  return base_type_name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ExtensionNumberResponse::set_base_type_name(const ::std::string& value) {
-  
-  base_type_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-}
-void ExtensionNumberResponse::set_base_type_name(const char* value) {
-  
-  base_type_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-}
-void ExtensionNumberResponse::set_base_type_name(const char* value, size_t size) {
-  
-  base_type_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-}
-::std::string* ExtensionNumberResponse::mutable_base_type_name() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-  return base_type_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ExtensionNumberResponse::release_base_type_name() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-  
-  return base_type_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ExtensionNumberResponse::set_allocated_base_type_name(::std::string* base_type_name) {
-  if (base_type_name != NULL) {
-    
-  } else {
-    
-  }
-  base_type_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), base_type_name);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ExtensionNumberResponse.base_type_name)
-}
-
-// repeated int32 extension_number = 2;
-int ExtensionNumberResponse::extension_number_size() const {
-  return extension_number_.size();
-}
-void ExtensionNumberResponse::clear_extension_number() {
-  extension_number_.Clear();
-}
-::google::protobuf::int32 ExtensionNumberResponse::extension_number(int index) const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ExtensionNumberResponse.extension_number)
-  return extension_number_.Get(index);
-}
-void ExtensionNumberResponse::set_extension_number(int index, ::google::protobuf::int32 value) {
-  extension_number_.Set(index, value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ExtensionNumberResponse.extension_number)
-}
-void ExtensionNumberResponse::add_extension_number(::google::protobuf::int32 value) {
-  extension_number_.Add(value);
-  // @@protoc_insertion_point(field_add:grpc.reflection.v1alpha.ExtensionNumberResponse.extension_number)
-}
-const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
-ExtensionNumberResponse::extension_number() const {
-  // @@protoc_insertion_point(field_list:grpc.reflection.v1alpha.ExtensionNumberResponse.extension_number)
-  return extension_number_;
-}
-::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
-ExtensionNumberResponse::mutable_extension_number() {
-  // @@protoc_insertion_point(field_mutable_list:grpc.reflection.v1alpha.ExtensionNumberResponse.extension_number)
-  return &extension_number_;
-}
-
-inline const ExtensionNumberResponse* ExtensionNumberResponse::internal_default_instance() {
-  return &ExtensionNumberResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ListServiceResponse::kServiceFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ListServiceResponse::ListServiceResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ListServiceResponse)
-}
-
-void ListServiceResponse::InitAsDefaultInstance() {
-}
-
-ListServiceResponse::ListServiceResponse(const ListServiceResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ListServiceResponse)
-}
-
-void ListServiceResponse::SharedCtor() {
-  _cached_size_ = 0;
-}
-
-ListServiceResponse::~ListServiceResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ListServiceResponse)
-  SharedDtor();
-}
-
-void ListServiceResponse::SharedDtor() {
-}
-
-void ListServiceResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ListServiceResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ListServiceResponse_descriptor_;
-}
-
-const ListServiceResponse& ListServiceResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ListServiceResponse> ListServiceResponse_default_instance_;
-
-ListServiceResponse* ListServiceResponse::New(::google::protobuf::Arena* arena) const {
-  ListServiceResponse* n = new ListServiceResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ListServiceResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ListServiceResponse)
-  service_.Clear();
-}
-
-bool ListServiceResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ListServiceResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(input->IncrementRecursionDepth());
-         parse_loop_service:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
-                input, add_service()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_loop_service;
-        input->UnsafeDecrementRecursionDepth();
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ListServiceResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ListServiceResponse)
-  return false;
-#undef DO_
-}
-
-void ListServiceResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ListServiceResponse)
-  // repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;
-  for (unsigned int i = 0, n = this->service_size(); i < n; i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->service(i), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ListServiceResponse)
-}
-
-::google::protobuf::uint8* ListServiceResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ListServiceResponse)
-  // repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;
-  for (unsigned int i = 0, n = this->service_size(); i < n; i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      InternalWriteMessageNoVirtualToArray(
-        1, this->service(i), false, target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ListServiceResponse)
-  return target;
-}
-
-size_t ListServiceResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ListServiceResponse)
-  size_t total_size = 0;
-
-  // repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;
-  {
-    unsigned int count = this->service_size();
-    total_size += 1UL * count;
-    for (unsigned int i = 0; i < count; i++) {
-      total_size +=
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->service(i));
-    }
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ListServiceResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ListServiceResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ListServiceResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ListServiceResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ListServiceResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ListServiceResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ListServiceResponse::MergeFrom(const ListServiceResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ListServiceResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ListServiceResponse::UnsafeMergeFrom(const ListServiceResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  service_.MergeFrom(from.service_);
-}
-
-void ListServiceResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ListServiceResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ListServiceResponse::CopyFrom(const ListServiceResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ListServiceResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ListServiceResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ListServiceResponse::Swap(ListServiceResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ListServiceResponse::InternalSwap(ListServiceResponse* other) {
-  service_.UnsafeArenaSwap(&other->service_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ListServiceResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ListServiceResponse_descriptor_;
-  metadata.reflection = ListServiceResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ListServiceResponse
-
-// repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;
-int ListServiceResponse::service_size() const {
-  return service_.size();
-}
-void ListServiceResponse::clear_service() {
-  service_.Clear();
-}
-const ::grpc::reflection::v1alpha::ServiceResponse& ListServiceResponse::service(int index) const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ListServiceResponse.service)
-  return service_.Get(index);
-}
-::grpc::reflection::v1alpha::ServiceResponse* ListServiceResponse::mutable_service(int index) {
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ListServiceResponse.service)
-  return service_.Mutable(index);
-}
-::grpc::reflection::v1alpha::ServiceResponse* ListServiceResponse::add_service() {
-  // @@protoc_insertion_point(field_add:grpc.reflection.v1alpha.ListServiceResponse.service)
-  return service_.Add();
-}
-::google::protobuf::RepeatedPtrField< ::grpc::reflection::v1alpha::ServiceResponse >*
-ListServiceResponse::mutable_service() {
-  // @@protoc_insertion_point(field_mutable_list:grpc.reflection.v1alpha.ListServiceResponse.service)
-  return &service_;
-}
-const ::google::protobuf::RepeatedPtrField< ::grpc::reflection::v1alpha::ServiceResponse >&
-ListServiceResponse::service() const {
-  // @@protoc_insertion_point(field_list:grpc.reflection.v1alpha.ListServiceResponse.service)
-  return service_;
-}
-
-inline const ListServiceResponse* ListServiceResponse::internal_default_instance() {
-  return &ListServiceResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ServiceResponse::kNameFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ServiceResponse::ServiceResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ServiceResponse)
-}
-
-void ServiceResponse::InitAsDefaultInstance() {
-}
-
-ServiceResponse::ServiceResponse(const ServiceResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ServiceResponse)
-}
-
-void ServiceResponse::SharedCtor() {
-  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  _cached_size_ = 0;
-}
-
-ServiceResponse::~ServiceResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ServiceResponse)
-  SharedDtor();
-}
-
-void ServiceResponse::SharedDtor() {
-  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-void ServiceResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ServiceResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ServiceResponse_descriptor_;
-}
-
-const ServiceResponse& ServiceResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ServiceResponse> ServiceResponse_default_instance_;
-
-ServiceResponse* ServiceResponse::New(::google::protobuf::Arena* arena) const {
-  ServiceResponse* n = new ServiceResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ServiceResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ServiceResponse)
-  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-bool ServiceResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ServiceResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string name = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_name()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->name().data(), this->name().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ServiceResponse.name"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ServiceResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ServiceResponse)
-  return false;
-#undef DO_
-}
-
-void ServiceResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ServiceResponse)
-  // optional string name = 1;
-  if (this->name().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServiceResponse.name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->name(), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ServiceResponse)
-}
-
-::google::protobuf::uint8* ServiceResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ServiceResponse)
-  // optional string name = 1;
-  if (this->name().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ServiceResponse.name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->name(), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ServiceResponse)
-  return target;
-}
-
-size_t ServiceResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ServiceResponse)
-  size_t total_size = 0;
-
-  // optional string name = 1;
-  if (this->name().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->name());
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ServiceResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ServiceResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ServiceResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ServiceResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ServiceResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ServiceResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ServiceResponse::MergeFrom(const ServiceResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ServiceResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ServiceResponse::UnsafeMergeFrom(const ServiceResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  if (from.name().size() > 0) {
-
-    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
-  }
-}
-
-void ServiceResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ServiceResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ServiceResponse::CopyFrom(const ServiceResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ServiceResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ServiceResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ServiceResponse::Swap(ServiceResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ServiceResponse::InternalSwap(ServiceResponse* other) {
-  name_.Swap(&other->name_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ServiceResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ServiceResponse_descriptor_;
-  metadata.reflection = ServiceResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ServiceResponse
-
-// optional string name = 1;
-void ServiceResponse::clear_name() {
-  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ServiceResponse::name() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ServiceResponse.name)
-  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServiceResponse::set_name(const ::std::string& value) {
-  
-  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ServiceResponse.name)
-}
-void ServiceResponse::set_name(const char* value) {
-  
-  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ServiceResponse.name)
-}
-void ServiceResponse::set_name(const char* value, size_t size) {
-  
-  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ServiceResponse.name)
-}
-::std::string* ServiceResponse::mutable_name() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ServiceResponse.name)
-  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ServiceResponse::release_name() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ServiceResponse.name)
-  
-  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ServiceResponse::set_allocated_name(::std::string* name) {
-  if (name != NULL) {
-    
-  } else {
-    
-  }
-  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ServiceResponse.name)
-}
-
-inline const ServiceResponse* ServiceResponse::internal_default_instance() {
-  return &ServiceResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// ===================================================================
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1900
-const int ErrorResponse::kErrorCodeFieldNumber;
-const int ErrorResponse::kErrorMessageFieldNumber;
-#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
-
-ErrorResponse::ErrorResponse()
-  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
-  if (this != internal_default_instance()) protobuf_InitDefaults_reflection_2eproto();
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:grpc.reflection.v1alpha.ErrorResponse)
-}
-
-void ErrorResponse::InitAsDefaultInstance() {
-}
-
-ErrorResponse::ErrorResponse(const ErrorResponse& from)
-  : ::google::protobuf::Message(),
-    _internal_metadata_(NULL) {
-  SharedCtor();
-  UnsafeMergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:grpc.reflection.v1alpha.ErrorResponse)
-}
-
-void ErrorResponse::SharedCtor() {
-  error_message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  error_code_ = 0;
-  _cached_size_ = 0;
-}
-
-ErrorResponse::~ErrorResponse() {
-  // @@protoc_insertion_point(destructor:grpc.reflection.v1alpha.ErrorResponse)
-  SharedDtor();
-}
-
-void ErrorResponse::SharedDtor() {
-  error_message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-void ErrorResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ErrorResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ErrorResponse_descriptor_;
-}
-
-const ErrorResponse& ErrorResponse::default_instance() {
-  protobuf_InitDefaults_reflection_2eproto();
-  return *internal_default_instance();
-}
-
-::google::protobuf::internal::ExplicitlyConstructed<ErrorResponse> ErrorResponse_default_instance_;
-
-ErrorResponse* ErrorResponse::New(::google::protobuf::Arena* arena) const {
-  ErrorResponse* n = new ErrorResponse;
-  if (arena != NULL) {
-    arena->Own(n);
-  }
-  return n;
-}
-
-void ErrorResponse::Clear() {
-// @@protoc_insertion_point(message_clear_start:grpc.reflection.v1alpha.ErrorResponse)
-  error_code_ = 0;
-  error_message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-
-bool ErrorResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:grpc.reflection.v1alpha.ErrorResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional int32 error_code = 1;
-      case 1: {
-        if (tag == 8) {
-
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &error_code_)));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_error_message;
-        break;
-      }
-
-      // optional string error_message = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_error_message:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_error_message()));
-          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-            this->error_message().data(), this->error_message().length(),
-            ::google::protobuf::internal::WireFormatLite::PARSE,
-            "grpc.reflection.v1alpha.ErrorResponse.error_message"));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:grpc.reflection.v1alpha.ErrorResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:grpc.reflection.v1alpha.ErrorResponse)
-  return false;
-#undef DO_
-}
-
-void ErrorResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:grpc.reflection.v1alpha.ErrorResponse)
-  // optional int32 error_code = 1;
-  if (this->error_code() != 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->error_code(), output);
-  }
-
-  // optional string error_message = 2;
-  if (this->error_message().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->error_message().data(), this->error_message().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ErrorResponse.error_message");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->error_message(), output);
-  }
-
-  // @@protoc_insertion_point(serialize_end:grpc.reflection.v1alpha.ErrorResponse)
-}
-
-::google::protobuf::uint8* ErrorResponse::InternalSerializeWithCachedSizesToArray(
-    bool deterministic, ::google::protobuf::uint8* target) const {
-  (void)deterministic; // Unused
-  // @@protoc_insertion_point(serialize_to_array_start:grpc.reflection.v1alpha.ErrorResponse)
-  // optional int32 error_code = 1;
-  if (this->error_code() != 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->error_code(), target);
-  }
-
-  // optional string error_message = 2;
-  if (this->error_message().size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
-      this->error_message().data(), this->error_message().length(),
-      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
-      "grpc.reflection.v1alpha.ErrorResponse.error_message");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->error_message(), target);
-  }
-
-  // @@protoc_insertion_point(serialize_to_array_end:grpc.reflection.v1alpha.ErrorResponse)
-  return target;
-}
-
-size_t ErrorResponse::ByteSizeLong() const {
-// @@protoc_insertion_point(message_byte_size_start:grpc.reflection.v1alpha.ErrorResponse)
-  size_t total_size = 0;
-
-  // optional int32 error_code = 1;
-  if (this->error_code() != 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::Int32Size(
-        this->error_code());
-  }
-
-  // optional string error_message = 2;
-  if (this->error_message().size() > 0) {
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::StringSize(
-        this->error_message());
-  }
-
-  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = cached_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ErrorResponse::MergeFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_merge_from_start:grpc.reflection.v1alpha.ErrorResponse)
-  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
-  const ErrorResponse* source =
-      ::google::protobuf::internal::DynamicCastToGenerated<const ErrorResponse>(
-          &from);
-  if (source == NULL) {
-  // @@protoc_insertion_point(generalized_merge_from_cast_fail:grpc.reflection.v1alpha.ErrorResponse)
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-  // @@protoc_insertion_point(generalized_merge_from_cast_success:grpc.reflection.v1alpha.ErrorResponse)
-    UnsafeMergeFrom(*source);
-  }
-}
-
-void ErrorResponse::MergeFrom(const ErrorResponse& from) {
-// @@protoc_insertion_point(class_specific_merge_from_start:grpc.reflection.v1alpha.ErrorResponse)
-  if (GOOGLE_PREDICT_TRUE(&from != this)) {
-    UnsafeMergeFrom(from);
-  } else {
-    MergeFromFail(__LINE__);
-  }
-}
-
-void ErrorResponse::UnsafeMergeFrom(const ErrorResponse& from) {
-  GOOGLE_DCHECK(&from != this);
-  if (from.error_code() != 0) {
-    set_error_code(from.error_code());
-  }
-  if (from.error_message().size() > 0) {
-
-    error_message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.error_message_);
-  }
-}
-
-void ErrorResponse::CopyFrom(const ::google::protobuf::Message& from) {
-// @@protoc_insertion_point(generalized_copy_from_start:grpc.reflection.v1alpha.ErrorResponse)
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ErrorResponse::CopyFrom(const ErrorResponse& from) {
-// @@protoc_insertion_point(class_specific_copy_from_start:grpc.reflection.v1alpha.ErrorResponse)
-  if (&from == this) return;
-  Clear();
-  UnsafeMergeFrom(from);
-}
-
-bool ErrorResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ErrorResponse::Swap(ErrorResponse* other) {
-  if (other == this) return;
-  InternalSwap(other);
-}
-void ErrorResponse::InternalSwap(ErrorResponse* other) {
-  std::swap(error_code_, other->error_code_);
-  error_message_.Swap(&other->error_message_);
-  _internal_metadata_.Swap(&other->_internal_metadata_);
-  std::swap(_cached_size_, other->_cached_size_);
-}
-
-::google::protobuf::Metadata ErrorResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ErrorResponse_descriptor_;
-  metadata.reflection = ErrorResponse_reflection_;
-  return metadata;
-}
-
-#if PROTOBUF_INLINE_NOT_IN_HEADERS
-// ErrorResponse
-
-// optional int32 error_code = 1;
-void ErrorResponse::clear_error_code() {
-  error_code_ = 0;
-}
-::google::protobuf::int32 ErrorResponse::error_code() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ErrorResponse.error_code)
-  return error_code_;
-}
-void ErrorResponse::set_error_code(::google::protobuf::int32 value) {
-  
-  error_code_ = value;
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ErrorResponse.error_code)
-}
-
-// optional string error_message = 2;
-void ErrorResponse::clear_error_message() {
-  error_message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-const ::std::string& ErrorResponse::error_message() const {
-  // @@protoc_insertion_point(field_get:grpc.reflection.v1alpha.ErrorResponse.error_message)
-  return error_message_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ErrorResponse::set_error_message(const ::std::string& value) {
-  
-  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
-  // @@protoc_insertion_point(field_set:grpc.reflection.v1alpha.ErrorResponse.error_message)
-}
-void ErrorResponse::set_error_message(const char* value) {
-  
-  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
-  // @@protoc_insertion_point(field_set_char:grpc.reflection.v1alpha.ErrorResponse.error_message)
-}
-void ErrorResponse::set_error_message(const char* value, size_t size) {
-  
-  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
-      ::std::string(reinterpret_cast<const char*>(value), size));
-  // @@protoc_insertion_point(field_set_pointer:grpc.reflection.v1alpha.ErrorResponse.error_message)
-}
-::std::string* ErrorResponse::mutable_error_message() {
-  
-  // @@protoc_insertion_point(field_mutable:grpc.reflection.v1alpha.ErrorResponse.error_message)
-  return error_message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-::std::string* ErrorResponse::release_error_message() {
-  // @@protoc_insertion_point(field_release:grpc.reflection.v1alpha.ErrorResponse.error_message)
-  
-  return error_message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-}
-void ErrorResponse::set_allocated_error_message(::std::string* error_message) {
-  if (error_message != NULL) {
-    
-  } else {
-    
-  }
-  error_message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_message);
-  // @@protoc_insertion_point(field_set_allocated:grpc.reflection.v1alpha.ErrorResponse.error_message)
-}
-
-inline const ErrorResponse* ErrorResponse::internal_default_instance() {
-  return &ErrorResponse_default_instance_.get();
-}
-#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace v1alpha
-}  // namespace reflection
-}  // namespace grpc
-
-// @@protoc_insertion_point(global_scope)
diff --git a/src/cpp/server/dynamic_thread_pool.cc b/src/cpp/server/dynamic_thread_pool.cc
index 4b226c2992..1fdc2edb25 100644
--- a/src/cpp/server/dynamic_thread_pool.cc
+++ b/src/cpp/server/dynamic_thread_pool.cc
@@ -31,16 +31,16 @@
  *
  */
 
-#include <grpc++/impl/sync.h>
-#include <grpc++/impl/thd.h>
+#include <mutex>
+#include <thread>
 
 #include "src/cpp/server/dynamic_thread_pool.h"
 
 namespace grpc {
 DynamicThreadPool::DynamicThread::DynamicThread(DynamicThreadPool* pool)
     : pool_(pool),
-      thd_(new grpc::thread(&DynamicThreadPool::DynamicThread::ThreadFunc,
-                            this)) {}
+      thd_(new std::thread(&DynamicThreadPool::DynamicThread::ThreadFunc,
+                           this)) {}
 DynamicThreadPool::DynamicThread::~DynamicThread() {
   thd_->join();
   thd_.reset();
@@ -49,7 +49,7 @@ DynamicThreadPool::DynamicThread::~DynamicThread() {
 void DynamicThreadPool::DynamicThread::ThreadFunc() {
   pool_->ThreadFunc();
   // Now that we have killed ourselves, we should reduce the thread count
-  grpc::unique_lock<grpc::mutex> lock(pool_->mu_);
+  std::unique_lock<std::mutex> lock(pool_->mu_);
   pool_->nthreads_--;
   // Move ourselves to dead list
   pool_->dead_threads_.push_back(this);
@@ -62,7 +62,7 @@ void DynamicThreadPool::DynamicThread::ThreadFunc() {
 void DynamicThreadPool::ThreadFunc() {
   for (;;) {
     // Wait until work is available or we are shutting down.
-    grpc::unique_lock<grpc::mutex> lock(mu_);
+    std::unique_lock<std::mutex> lock(mu_);
     if (!shutdown_ && callbacks_.empty()) {
       // If there are too many threads waiting, then quit this thread
       if (threads_waiting_ >= reserve_threads_) {
@@ -91,7 +91,7 @@ DynamicThreadPool::DynamicThreadPool(int reserve_threads)
       nthreads_(0),
       threads_waiting_(0) {
   for (int i = 0; i < reserve_threads_; i++) {
-    grpc::lock_guard<grpc::mutex> lock(mu_);
+    std::lock_guard<std::mutex> lock(mu_);
     nthreads_++;
     new DynamicThread(this);
   }
@@ -104,7 +104,7 @@ void DynamicThreadPool::ReapThreads(std::list<DynamicThread*>* tlist) {
 }
 
 DynamicThreadPool::~DynamicThreadPool() {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   shutdown_ = true;
   cv_.notify_all();
   while (nthreads_ != 0) {
@@ -114,7 +114,7 @@ DynamicThreadPool::~DynamicThreadPool() {
 }
 
 void DynamicThreadPool::Add(const std::function<void()>& callback) {
-  grpc::lock_guard<grpc::mutex> lock(mu_);
+  std::lock_guard<std::mutex> lock(mu_);
   // Add works to the callbacks list
   callbacks_.push(callback);
   // Increase pool size or notify as needed
diff --git a/src/cpp/server/dynamic_thread_pool.h b/src/cpp/server/dynamic_thread_pool.h
index 5ba7533c05..4f8c4111cc 100644
--- a/src/cpp/server/dynamic_thread_pool.h
+++ b/src/cpp/server/dynamic_thread_pool.h
@@ -34,24 +34,25 @@
 #ifndef GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
 #define GRPC_INTERNAL_CPP_DYNAMIC_THREAD_POOL_H
 
+#include <condition_variable>
 #include <list>
 #include <memory>
+#include <mutex>
 #include <queue>
+#include <thread>
 
-#include <grpc++/impl/sync.h>
-#include <grpc++/impl/thd.h>
 #include <grpc++/support/config.h>
 
 #include "src/cpp/server/thread_pool_interface.h"
 
 namespace grpc {
 
-class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface {
+class DynamicThreadPool final : public ThreadPoolInterface {
  public:
   explicit DynamicThreadPool(int reserve_threads);
   ~DynamicThreadPool();
 
-  void Add(const std::function<void()>& callback) GRPC_OVERRIDE;
+  void Add(const std::function<void()>& callback) override;
 
  private:
   class DynamicThread {
@@ -61,12 +62,12 @@ class DynamicThreadPool GRPC_FINAL : public ThreadPoolInterface {
 
    private:
     DynamicThreadPool* pool_;
-    std::unique_ptr<grpc::thread> thd_;
+    std::unique_ptr<std::thread> thd_;
     void ThreadFunc();
   };
-  grpc::mutex mu_;
-  grpc::condition_variable cv_;
-  grpc::condition_variable shutdown_cv_;
+  std::mutex mu_;
+  std::condition_variable cv_;
+  std::condition_variable shutdown_cv_;
   bool shutdown_;
   std::queue<std::function<void()>> callbacks_;
   int reserve_threads_;
diff --git a/src/cpp/server/insecure_server_credentials.cc b/src/cpp/server/insecure_server_credentials.cc
index ef3cae5fd7..eb5931b7b0 100644
--- a/src/cpp/server/insecure_server_credentials.cc
+++ b/src/cpp/server/insecure_server_credentials.cc
@@ -38,14 +38,13 @@
 
 namespace grpc {
 namespace {
-class InsecureServerCredentialsImpl GRPC_FINAL : public ServerCredentials {
+class InsecureServerCredentialsImpl final : public ServerCredentials {
  public:
-  int AddPortToServer(const grpc::string& addr,
-                      grpc_server* server) GRPC_OVERRIDE {
+  int AddPortToServer(const grpc::string& addr, grpc_server* server) override {
     return grpc_server_add_insecure_http2_port(server, addr.c_str());
   }
   void SetAuthMetadataProcessor(
-      const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE {
+      const std::shared_ptr<AuthMetadataProcessor>& processor) override {
     (void)processor;
     GPR_ASSERT(0);  // Should not be called on InsecureServerCredentials.
   }
diff --git a/src/cpp/server/secure_server_credentials.h b/src/cpp/server/secure_server_credentials.h
index 5460f4a02c..3a301e60c2 100644
--- a/src/cpp/server/secure_server_credentials.h
+++ b/src/cpp/server/secure_server_credentials.h
@@ -44,7 +44,7 @@
 
 namespace grpc {
 
-class AuthMetadataProcessorAyncWrapper GRPC_FINAL {
+class AuthMetadataProcessorAyncWrapper final {
  public:
   static void Destroy(void* wrapper);
 
@@ -64,19 +64,18 @@ class AuthMetadataProcessorAyncWrapper GRPC_FINAL {
   std::shared_ptr<AuthMetadataProcessor> processor_;
 };
 
-class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
+class SecureServerCredentials final : public ServerCredentials {
  public:
   explicit SecureServerCredentials(grpc_server_credentials* creds)
       : creds_(creds) {}
-  ~SecureServerCredentials() GRPC_OVERRIDE {
+  ~SecureServerCredentials() override {
     grpc_server_credentials_release(creds_);
   }
 
-  int AddPortToServer(const grpc::string& addr,
-                      grpc_server* server) GRPC_OVERRIDE;
+  int AddPortToServer(const grpc::string& addr, grpc_server* server) override;
 
   void SetAuthMetadataProcessor(
-      const std::shared_ptr<AuthMetadataProcessor>& processor) GRPC_OVERRIDE;
+      const std::shared_ptr<AuthMetadataProcessor>& processor) override;
 
  private:
   grpc_server_credentials* creds_;
diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc
index 2980b16c56..00a90bb184 100644
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@@ -34,7 +34,9 @@
 #include <grpc++/server_builder.h>
 
 #include <grpc++/impl/service_type.h>
+#include <grpc++/resource_quota.h>
 #include <grpc++/server.h>
+#include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
@@ -54,6 +56,8 @@ static void do_plugin_list_init(void) {
 ServerBuilder::ServerBuilder()
     : max_receive_message_size_(-1),
       max_send_message_size_(-1),
+      sync_server_settings_(SyncServerSettings()),
+      resource_quota_(nullptr),
       generic_service_(nullptr) {
   gpr_once_init(&once_init_plugin_list, do_plugin_list_init);
   for (auto it = g_plugin_factory_list->begin();
@@ -61,6 +65,7 @@ ServerBuilder::ServerBuilder()
     auto& factory = *it;
     plugins_.emplace_back(factory());
   }
+
   // all compression algorithms enabled by default.
   enabled_compression_algorithms_bitset_ =
       (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
@@ -70,6 +75,12 @@ ServerBuilder::ServerBuilder()
          sizeof(maybe_default_compression_algorithm_));
 }
 
+ServerBuilder::~ServerBuilder() {
+  if (resource_quota_ != nullptr) {
+    grpc_resource_quota_unref(resource_quota_);
+  }
+}
+
 std::unique_ptr<ServerCompletionQueue> ServerBuilder::AddCompletionQueue(
     bool is_frequently_polled) {
   ServerCompletionQueue* cq = new ServerCompletionQueue(is_frequently_polled);
@@ -94,7 +105,7 @@ ServerBuilder& ServerBuilder::RegisterAsyncGenericService(
     gpr_log(GPR_ERROR,
             "Adding multiple AsyncGenericService is unsupported for now. "
             "Dropping the service %p",
-            service);
+            (void*)service);
   } else {
     generic_service_ = service;
   }
@@ -107,6 +118,25 @@ ServerBuilder& ServerBuilder::SetOption(
   return *this;
 }
 
+ServerBuilder& ServerBuilder::SetSyncServerOption(
+    ServerBuilder::SyncServerOption option, int val) {
+  switch (option) {
+    case NUM_CQS:
+      sync_server_settings_.num_cqs = val;
+      break;
+    case MIN_POLLERS:
+      sync_server_settings_.min_pollers = val;
+      break;
+    case MAX_POLLERS:
+      sync_server_settings_.max_pollers = val;
+      break;
+    case CQ_TIMEOUT_MSEC:
+      sync_server_settings_.cq_timeout_msec = val;
+      break;
+  }
+  return *this;
+}
+
 ServerBuilder& ServerBuilder::SetCompressionAlgorithmSupportStatus(
     grpc_compression_algorithm algorithm, bool enabled) {
   if (enabled) {
@@ -130,6 +160,16 @@ ServerBuilder& ServerBuilder::SetDefaultCompressionAlgorithm(
   return *this;
 }
 
+ServerBuilder& ServerBuilder::SetResourceQuota(
+    const grpc::ResourceQuota& resource_quota) {
+  if (resource_quota_ != nullptr) {
+    grpc_resource_quota_unref(resource_quota_);
+  }
+  resource_quota_ = resource_quota.c_resource_quota();
+  grpc_resource_quota_ref(resource_quota_);
+  return *this;
+}
+
 ServerBuilder& ServerBuilder::AddListeningPort(
     const grpc::string& addr, std::shared_ptr<ServerCredentials> creds,
     int* selected_port) {
@@ -139,35 +179,24 @@ ServerBuilder& ServerBuilder::AddListeningPort(
 }
 
 std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
-  std::unique_ptr<ThreadPoolInterface> thread_pool;
-  bool has_sync_methods = false;
-  for (auto it = services_.begin(); it != services_.end(); ++it) {
-    if ((*it)->service->has_synchronous_methods()) {
-      if (!thread_pool) {
-        thread_pool.reset(CreateDefaultThreadPool());
-        has_sync_methods = true;
-        break;
-      }
-    }
-  }
   ChannelArguments args;
   for (auto option = options_.begin(); option != options_.end(); ++option) {
     (*option)->UpdateArguments(&args);
     (*option)->UpdatePlugins(&plugins_);
   }
+
   for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
-    if (!thread_pool && (*plugin)->has_sync_methods()) {
-      thread_pool.reset(CreateDefaultThreadPool());
-      has_sync_methods = true;
-    }
     (*plugin)->UpdateChannelArguments(&args);
   }
+
   if (max_receive_message_size_ >= 0) {
     args.SetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, max_receive_message_size_);
   }
+
   if (max_send_message_size_ >= 0) {
     args.SetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, max_send_message_size_);
   }
+
   args.SetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
               enabled_compression_algorithms_bitset_);
   if (maybe_default_compression_level_.is_set) {
@@ -178,27 +207,89 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
     args.SetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
                 maybe_default_compression_algorithm_.algorithm);
   }
-  std::unique_ptr<Server> server(new Server(thread_pool.release(), true,
-                                            max_receive_message_size_, &args));
+
+  if (resource_quota_ != nullptr) {
+    args.SetPointerWithVtable(GRPC_ARG_RESOURCE_QUOTA, resource_quota_,
+                              grpc_resource_quota_arg_vtable());
+  }
+
+  // == Determine if the server has any syncrhonous methods ==
+  bool has_sync_methods = false;
+  for (auto it = services_.begin(); it != services_.end(); ++it) {
+    if ((*it)->service->has_synchronous_methods()) {
+      has_sync_methods = true;
+      break;
+    }
+  }
+
+  if (!has_sync_methods) {
+    for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
+      if ((*plugin)->has_sync_methods()) {
+        has_sync_methods = true;
+        break;
+      }
+    }
+  }
+
+  // If this is a Sync server, i.e a server expositing sync API, then the server
+  // needs to create some completion queues to listen for incoming requests.
+  // 'sync_server_cqs' are those internal completion queues.
+  //
+  // This is different from the completion queues added to the server via
+  // ServerBuilder's AddCompletionQueue() method (those completion queues
+  // are in 'cqs_' member variable of ServerBuilder object)
+  std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+      sync_server_cqs(std::make_shared<
+                      std::vector<std::unique_ptr<ServerCompletionQueue>>>());
+
+  if (has_sync_methods) {
+    // This is a Sync server
+    gpr_log(GPR_INFO,
+            "Synchronous server. Num CQs: %d, Min pollers: %d, Max Pollers: "
+            "%d, CQ timeout (msec): %d",
+            sync_server_settings_.num_cqs, sync_server_settings_.min_pollers,
+            sync_server_settings_.max_pollers,
+            sync_server_settings_.cq_timeout_msec);
+
+    // Create completion queues to listen to incoming rpc requests
+    for (int i = 0; i < sync_server_settings_.num_cqs; i++) {
+      sync_server_cqs->emplace_back(new ServerCompletionQueue());
+    }
+  }
+
+  std::unique_ptr<Server> server(new Server(
+      max_receive_message_size_, &args, sync_server_cqs,
+      sync_server_settings_.min_pollers, sync_server_settings_.max_pollers,
+      sync_server_settings_.cq_timeout_msec));
+
   ServerInitializer* initializer = server->initializer();
 
-  // If the server has atleast one sync methods, we know that this is a Sync
-  // server or a Hybrid server and the completion queue (server->cq_) would be
-  // frequently polled.
-  int num_frequently_polled_cqs = has_sync_methods ? 1 : 0;
-
-  for (auto cq = cqs_.begin(); cq != cqs_.end(); ++cq) {
-    // A completion queue that is not polled frequently (by calling Next() or
-    // AsyncNext()) is not safe to use for listening to incoming channels.
-    // Register all such completion queues as non-listening completion queues
-    // with the GRPC core library.
-    if ((*cq)->IsFrequentlyPolled()) {
-      grpc_server_register_completion_queue(server->server_, (*cq)->cq(),
+  // Register all the completion queues with the server. i.e
+  //  1. sync_server_cqs: internal completion queues created IF this is a sync
+  //     server
+  //  2. cqs_: Completion queues added via AddCompletionQueue() call
+
+  // All sync cqs (if any) are frequently polled by ThreadManager
+  int num_frequently_polled_cqs = sync_server_cqs->size();
+
+  for (auto it = sync_server_cqs->begin(); it != sync_server_cqs->end(); ++it) {
+    grpc_server_register_completion_queue(server->server_, (*it)->cq(),
+                                          nullptr);
+  }
+
+  // cqs_ contains the completion queue added by calling the ServerBuilder's
+  // AddCompletionQueue() API. Some of them may not be frequently polled (i.e by
+  // calling Next() or AsyncNext()) and hence are not safe to be used for
+  // listening to incoming channels. Such completion queues must be registered
+  // as non-listening queues
+  for (auto it = cqs_.begin(); it != cqs_.end(); ++it) {
+    if ((*it)->IsFrequentlyPolled()) {
+      grpc_server_register_completion_queue(server->server_, (*it)->cq(),
                                             nullptr);
       num_frequently_polled_cqs++;
     } else {
       grpc_server_register_non_listening_completion_queue(server->server_,
-                                                          (*cq)->cq(), nullptr);
+                                                          (*it)->cq(), nullptr);
     }
   }
 
@@ -214,9 +305,11 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
       return nullptr;
     }
   }
+
   for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
     (*plugin)->InitServer(initializer);
   }
+
   if (generic_service_) {
     server->RegisterAsyncGenericService(generic_service_);
   } else {
@@ -229,6 +322,7 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
       }
     }
   }
+
   for (auto port = ports_.begin(); port != ports_.end(); port++) {
     int r = server->AddListeningPort(port->addr, port->creds.get());
     if (!r) return nullptr;
@@ -236,13 +330,16 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
       *port->selected_port = r;
     }
   }
+
   auto cqs_data = cqs_.empty() ? nullptr : &cqs_[0];
   if (!server->Start(cqs_data, cqs_.size())) {
     return nullptr;
   }
+
   for (auto plugin = plugins_.begin(); plugin != plugins_.end(); plugin++) {
     (*plugin)->Finish(initializer);
   }
+
   return server;
 }
 
diff --git a/src/cpp/server/server_cc.cc b/src/cpp/server/server_cc.cc
index 3f89275370..b7cfd6dbf1 100644
--- a/src/cpp/server/server_cc.cc
+++ b/src/cpp/server/server_cc.cc
@@ -1,5 +1,4 @@
 /*
- *
  * Copyright 2015, Google Inc.
  * All rights reserved.
  *
@@ -52,15 +51,15 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/profiling/timers.h"
-#include "src/cpp/server/thread_pool_interface.h"
+#include "src/cpp/thread_manager/thread_manager.h"
 
 namespace grpc {
 
-class DefaultGlobalCallbacks GRPC_FINAL : public Server::GlobalCallbacks {
+class DefaultGlobalCallbacks final : public Server::GlobalCallbacks {
  public:
-  ~DefaultGlobalCallbacks() GRPC_OVERRIDE {}
-  void PreSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {}
-  void PostSynchronousRequest(ServerContext* context) GRPC_OVERRIDE {}
+  ~DefaultGlobalCallbacks() override {}
+  void PreSynchronousRequest(ServerContext* context) override {}
+  void PostSynchronousRequest(ServerContext* context) override {}
 };
 
 static std::shared_ptr<Server::GlobalCallbacks> g_callbacks = nullptr;
@@ -80,7 +79,7 @@ class Server::UnimplementedAsyncRequestContext {
   GenericServerAsyncReaderWriter generic_stream_;
 };
 
-class Server::UnimplementedAsyncRequest GRPC_FINAL
+class Server::UnimplementedAsyncRequest final
     : public UnimplementedAsyncRequestContext,
       public GenericAsyncRequest {
  public:
@@ -90,7 +89,7 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
         server_(server),
         cq_(cq) {}
 
-  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE;
+  bool FinalizeResult(void** tag, bool* status) override;
 
   ServerContext* context() { return &server_context_; }
   GenericServerAsyncReaderWriter* stream() { return &generic_stream_; }
@@ -102,13 +101,13 @@ class Server::UnimplementedAsyncRequest GRPC_FINAL
 
 typedef SneakyCallOpSet<CallOpSendInitialMetadata, CallOpServerSendStatus>
     UnimplementedAsyncResponseOp;
-class Server::UnimplementedAsyncResponse GRPC_FINAL
+class Server::UnimplementedAsyncResponse final
     : public UnimplementedAsyncResponseOp {
  public:
   UnimplementedAsyncResponse(UnimplementedAsyncRequest* request);
   ~UnimplementedAsyncResponse() { delete request_; }
 
-  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
+  bool FinalizeResult(void** tag, bool* status) override {
     bool r = UnimplementedAsyncResponseOp::FinalizeResult(tag, status);
     delete this;
     return r;
@@ -118,15 +117,12 @@ class Server::UnimplementedAsyncResponse GRPC_FINAL
   UnimplementedAsyncRequest* const request_;
 };
 
-class Server::ShutdownRequest GRPC_FINAL : public CompletionQueueTag {
+class ShutdownTag : public CompletionQueueTag {
  public:
-  bool FinalizeResult(void** tag, bool* status) {
-    delete this;
-    return false;
-  }
+  bool FinalizeResult(void** tag, bool* status) { return false; }
 };
 
-class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
+class Server::SyncRequest final : public CompletionQueueTag {
  public:
   SyncRequest(RpcServiceMethod* method, void* tag)
       : method_(method),
@@ -147,36 +143,6 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
     grpc_metadata_array_destroy(&request_metadata_);
   }
 
-  static SyncRequest* Wait(CompletionQueue* cq, bool* ok) {
-    void* tag = nullptr;
-    *ok = false;
-    if (!cq->Next(&tag, ok)) {
-      return nullptr;
-    }
-    auto* mrd = static_cast<SyncRequest*>(tag);
-    GPR_ASSERT(mrd->in_flight_);
-    return mrd;
-  }
-
-  static bool AsyncWait(CompletionQueue* cq, SyncRequest** req, bool* ok,
-                        gpr_timespec deadline) {
-    void* tag = nullptr;
-    *ok = false;
-    switch (cq->AsyncNext(&tag, ok, deadline)) {
-      case CompletionQueue::TIMEOUT:
-        *req = nullptr;
-        return true;
-      case CompletionQueue::SHUTDOWN:
-        *req = nullptr;
-        return false;
-      case CompletionQueue::GOT_EVENT:
-        *req = static_cast<SyncRequest*>(tag);
-        GPR_ASSERT((*req)->in_flight_);
-        return true;
-    }
-    GPR_UNREACHABLE_CODE(return false);
-  }
-
   void SetupRequest() { cq_ = grpc_completion_queue_create(nullptr); }
 
   void TeardownRequest() {
@@ -204,7 +170,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
     }
   }
 
-  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
+  bool FinalizeResult(void** tag, bool* status) override {
     if (!*status) {
       grpc_completion_queue_destroy(cq_);
     }
@@ -216,7 +182,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
     return true;
   }
 
-  class CallData GRPC_FINAL {
+  class CallData final {
    public:
     explicit CallData(Server* server, SyncRequest* mrd)
         : cq_(mrd->cq_),
@@ -266,7 +232,6 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
   void* const tag_;
   bool in_flight_;
   const bool has_request_payload_;
-  uint32_t incoming_flags_;
   grpc_call* call_;
   grpc_call_details* call_details_;
   gpr_timespec deadline_;
@@ -275,53 +240,158 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
   grpc_completion_queue* cq_;
 };
 
+// Implementation of ThreadManager. Each instance of SyncRequestThreadManager
+// manages a pool of threads that poll for incoming Sync RPCs and call the
+// appropriate RPC handlers
+class Server::SyncRequestThreadManager : public ThreadManager {
+ public:
+  SyncRequestThreadManager(Server* server, CompletionQueue* server_cq,
+                           std::shared_ptr<GlobalCallbacks> global_callbacks,
+                           int min_pollers, int max_pollers,
+                           int cq_timeout_msec)
+      : ThreadManager(min_pollers, max_pollers),
+        server_(server),
+        server_cq_(server_cq),
+        cq_timeout_msec_(cq_timeout_msec),
+        global_callbacks_(global_callbacks) {}
+
+  WorkStatus PollForWork(void** tag, bool* ok) override {
+    *tag = nullptr;
+    gpr_timespec deadline =
+        gpr_time_from_millis(cq_timeout_msec_, GPR_TIMESPAN);
+
+    switch (server_cq_->AsyncNext(tag, ok, deadline)) {
+      case CompletionQueue::TIMEOUT:
+        return TIMEOUT;
+      case CompletionQueue::SHUTDOWN:
+        return SHUTDOWN;
+      case CompletionQueue::GOT_EVENT:
+        return WORK_FOUND;
+    }
+
+    GPR_UNREACHABLE_CODE(return TIMEOUT);
+  }
+
+  void DoWork(void* tag, bool ok) override {
+    SyncRequest* sync_req = static_cast<SyncRequest*>(tag);
+
+    if (!sync_req) {
+      // No tag. Nothing to work on. This is an unlikley scenario and possibly a
+      // bug in RPC Manager implementation.
+      gpr_log(GPR_ERROR, "Sync server. DoWork() was called with NULL tag");
+      return;
+    }
+
+    if (ok) {
+      // Calldata takes ownership of the completion queue inside sync_req
+      SyncRequest::CallData cd(server_, sync_req);
+      {
+        // Prepare for the next request
+        if (!IsShutdown()) {
+          sync_req->SetupRequest();  // Create new completion queue for sync_req
+          sync_req->Request(server_->c_server(), server_cq_->cq());
+        }
+      }
+
+      GPR_TIMER_SCOPE("cd.Run()", 0);
+      cd.Run(global_callbacks_);
+    }
+    // TODO (sreek) If ok is false here (which it isn't in case of
+    // grpc_request_registered_call), we should still re-queue the request
+    // object
+  }
+
+  void AddSyncMethod(RpcServiceMethod* method, void* tag) {
+    sync_requests_.emplace_back(new SyncRequest(method, tag));
+  }
+
+  void AddUnknownSyncMethod() {
+    if (!sync_requests_.empty()) {
+      unknown_method_.reset(new RpcServiceMethod(
+          "unknown", RpcMethod::BIDI_STREAMING, new UnknownMethodHandler));
+      sync_requests_.emplace_back(
+          new SyncRequest(unknown_method_.get(), nullptr));
+    }
+  }
+
+  void ShutdownAndDrainCompletionQueue() {
+    server_cq_->Shutdown();
+
+    // Drain any pending items from the queue
+    void* tag;
+    bool ok;
+    while (server_cq_->Next(&tag, &ok)) {
+      // Nothing to be done here
+    }
+  }
+
+  void Start() {
+    if (!sync_requests_.empty()) {
+      for (auto m = sync_requests_.begin(); m != sync_requests_.end(); m++) {
+        (*m)->SetupRequest();
+        (*m)->Request(server_->c_server(), server_cq_->cq());
+      }
+
+      Initialize();  // ThreadManager's Initialize()
+    }
+  }
+
+ private:
+  Server* server_;
+  CompletionQueue* server_cq_;
+  int cq_timeout_msec_;
+  std::vector<std::unique_ptr<SyncRequest>> sync_requests_;
+  std::unique_ptr<RpcServiceMethod> unknown_method_;
+  std::shared_ptr<Server::GlobalCallbacks> global_callbacks_;
+};
+
 static internal::GrpcLibraryInitializer g_gli_initializer;
-Server::Server(ThreadPoolInterface* thread_pool, bool thread_pool_owned,
-               int max_receive_message_size, ChannelArguments* args)
+Server::Server(
+    int max_receive_message_size, ChannelArguments* args,
+    std::shared_ptr<std::vector<std::unique_ptr<ServerCompletionQueue>>>
+        sync_server_cqs,
+    int min_pollers, int max_pollers, int sync_cq_timeout_msec)
     : max_receive_message_size_(max_receive_message_size),
+      sync_server_cqs_(sync_server_cqs),
       started_(false),
       shutdown_(false),
       shutdown_notified_(false),
-      num_running_cb_(0),
-      sync_methods_(new std::list<SyncRequest>),
       has_generic_service_(false),
       server_(nullptr),
-      thread_pool_(thread_pool),
-      thread_pool_owned_(thread_pool_owned),
       server_initializer_(new ServerInitializer(this)) {
   g_gli_initializer.summon();
   gpr_once_init(&g_once_init_callbacks, InitGlobalCallbacks);
   global_callbacks_ = g_callbacks;
   global_callbacks_->UpdateArguments(args);
+
+  for (auto it = sync_server_cqs_->begin(); it != sync_server_cqs_->end();
+       it++) {
+    sync_req_mgrs_.emplace_back(new SyncRequestThreadManager(
+        this, (*it).get(), global_callbacks_, min_pollers, max_pollers,
+        sync_cq_timeout_msec));
+  }
+
   grpc_channel_args channel_args;
   args->SetChannelArgs(&channel_args);
+
   server_ = grpc_server_create(&channel_args, nullptr);
-  if (thread_pool_ == nullptr) {
-    grpc_server_register_non_listening_completion_queue(server_, cq_.cq(),
-                                                        nullptr);
-  } else {
-    grpc_server_register_completion_queue(server_, cq_.cq(), nullptr);
-  }
 }
 
 Server::~Server() {
   {
-    grpc::unique_lock<grpc::mutex> lock(mu_);
+    std::unique_lock<std::mutex> lock(mu_);
     if (started_ && !shutdown_) {
       lock.unlock();
       Shutdown();
     } else if (!started_) {
-      cq_.Shutdown();
+      // Shutdown the completion queues
+      for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+        (*it)->ShutdownAndDrainCompletionQueue();
+      }
     }
   }
-  void* got_tag;
-  bool ok;
-  GPR_ASSERT(!cq_.Next(&got_tag, &ok));
+
   grpc_server_destroy(server_);
-  if (thread_pool_owned_) {
-    delete thread_pool_;
-  }
-  delete sync_methods_;
 }
 
 void Server::SetGlobalCallbacks(GlobalCallbacks* callbacks) {
@@ -352,12 +422,14 @@ bool Server::RegisterService(const grpc::string* host, Service* service) {
                "Can only register an asynchronous service against one server.");
     service->server_ = this;
   }
+
   const char* method_name = nullptr;
   for (auto it = service->methods_.begin(); it != service->methods_.end();
        ++it) {
     if (it->get() == nullptr) {  // Handled by generic service if any.
       continue;
     }
+
     RpcServiceMethod* method = it->get();
     void* tag = grpc_server_register_method(
         server_, method->name(), host ? host->c_str() : nullptr,
@@ -367,11 +439,15 @@ bool Server::RegisterService(const grpc::string* host, Service* service) {
               method->name());
       return false;
     }
-    if (method->handler() == nullptr) {
+
+    if (method->handler() == nullptr) {  // Async method
       method->set_server_tag(tag);
     } else {
-      sync_methods_->emplace_back(method, tag);
+      for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+        (*it)->AddSyncMethod(method, tag);
+      }
     }
+
     method_name = method->name();
   }
 
@@ -406,60 +482,65 @@ bool Server::Start(ServerCompletionQueue** cqs, size_t num_cqs) {
   grpc_server_start(server_);
 
   if (!has_generic_service_) {
-    if (!sync_methods_->empty()) {
-      unknown_method_.reset(new RpcServiceMethod(
-          "unknown", RpcMethod::BIDI_STREAMING, new UnknownMethodHandler));
-      // Use of emplace_back with just constructor arguments is not accepted
-      // here by gcc-4.4 because it can't match the anonymous nullptr with a
-      // proper constructor implicitly. Construct the object and use push_back.
-      sync_methods_->push_back(SyncRequest(unknown_method_.get(), nullptr));
+    for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+      (*it)->AddUnknownSyncMethod();
     }
+
     for (size_t i = 0; i < num_cqs; i++) {
       if (cqs[i]->IsFrequentlyPolled()) {
         new UnimplementedAsyncRequest(this, cqs[i]);
       }
     }
   }
-  // Start processing rpcs.
-  if (!sync_methods_->empty()) {
-    for (auto m = sync_methods_->begin(); m != sync_methods_->end(); m++) {
-      m->SetupRequest();
-      m->Request(server_, cq_.cq());
-    }
 
-    ScheduleCallback();
+  for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+    (*it)->Start();
   }
 
   return true;
 }
 
 void Server::ShutdownInternal(gpr_timespec deadline) {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   if (started_ && !shutdown_) {
     shutdown_ = true;
-    grpc_server_shutdown_and_notify(server_, cq_.cq(), new ShutdownRequest());
-    cq_.Shutdown();
-    lock.unlock();
-    // Spin, eating requests until the completion queue is completely shutdown.
-    // If the deadline expires then cancel anything that's pending and keep
-    // spinning forever until the work is actually drained.
-    // Since nothing else needs to touch state guarded by mu_, holding it
-    // through this loop is fine.
-    SyncRequest* request;
+
+    /// The completion queue to use for server shutdown completion notification
+    CompletionQueue shutdown_cq;
+    ShutdownTag shutdown_tag;  // Dummy shutdown tag
+    grpc_server_shutdown_and_notify(server_, shutdown_cq.cq(), &shutdown_tag);
+
+    // Shutdown all ThreadManagers. This will try to gracefully stop all the
+    // threads in the ThreadManagers (once they process any inflight requests)
+    for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+      (*it)->Shutdown();  // ThreadManager's Shutdown()
+    }
+
+    shutdown_cq.Shutdown();
+
+    void* tag;
     bool ok;
-    while (SyncRequest::AsyncWait(&cq_, &request, &ok, deadline)) {
-      if (request == NULL) {  // deadline expired
-        grpc_server_cancel_all_calls(server_);
-        deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
-      } else if (ok) {
-        SyncRequest::CallData call_data(this, request);
-      }
+    CompletionQueue::NextStatus status =
+        shutdown_cq.AsyncNext(&tag, &ok, deadline);
+
+    // If this timed out, it means we are done with the grace period for a clean
+    // shutdown. We should force a shutdown now by cancelling all inflight calls
+    if (status == CompletionQueue::NextStatus::TIMEOUT) {
+      grpc_server_cancel_all_calls(server_);
+    }
+    // Else in case of SHUTDOWN or GOT_EVENT, it means that the server has
+    // successfully shutdown
+
+    // Wait for threads in all ThreadManagers to terminate
+    for (auto it = sync_req_mgrs_.begin(); it != sync_req_mgrs_.end(); it++) {
+      (*it)->Wait();
+      (*it)->ShutdownAndDrainCompletionQueue();
     }
-    lock.lock();
 
-    // Wait for running callbacks to finish.
-    while (num_running_cb_ != 0) {
-      callback_cv_.wait(lock);
+    // Drain the shutdown queue (if the previous call to AsyncNext() timed out
+    // and we didn't remove the tag from the queue yet)
+    while (shutdown_cq.Next(&tag, &ok)) {
+      // Nothing to be done here. Just ignore ok and tag values
     }
 
     shutdown_notified_ = true;
@@ -468,7 +549,7 @@ void Server::ShutdownInternal(gpr_timespec deadline) {
 }
 
 void Server::Wait() {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   while (started_ && !shutdown_notified_) {
     shutdown_cv_.wait(lock);
   }
@@ -585,47 +666,6 @@ Server::UnimplementedAsyncResponse::UnimplementedAsyncResponse(
   request_->stream()->call_.PerformOps(this);
 }
 
-void Server::ScheduleCallback() {
-  {
-    grpc::unique_lock<grpc::mutex> lock(mu_);
-    num_running_cb_++;
-  }
-  thread_pool_->Add(std::bind(&Server::RunRpc, this));
-}
-
-void Server::RunRpc() {
-  // Wait for one more incoming rpc.
-  bool ok;
-  GPR_TIMER_SCOPE("Server::RunRpc", 0);
-  auto* mrd = SyncRequest::Wait(&cq_, &ok);
-  if (mrd) {
-    ScheduleCallback();
-    if (ok) {
-      SyncRequest::CallData cd(this, mrd);
-      {
-        mrd->SetupRequest();
-        grpc::unique_lock<grpc::mutex> lock(mu_);
-        if (!shutdown_) {
-          mrd->Request(server_, cq_.cq());
-        } else {
-          // destroy the structure that was created
-          mrd->TeardownRequest();
-        }
-      }
-      GPR_TIMER_SCOPE("cd.Run()", 0);
-      cd.Run(global_callbacks_);
-    }
-  }
-
-  {
-    grpc::unique_lock<grpc::mutex> lock(mu_);
-    num_running_cb_--;
-    if (shutdown_) {
-      callback_cv_.notify_all();
-    }
-  }
-}
-
 ServerInitializer* Server::initializer() { return server_initializer_.get(); }
 
 }  // namespace grpc
diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc
index 1ca6a2b906..a66ec4ac84 100644
--- a/src/cpp/server/server_context.cc
+++ b/src/cpp/server/server_context.cc
@@ -33,9 +33,10 @@
 
 #include <grpc++/server_context.h>
 
+#include <mutex>
+
 #include <grpc++/completion_queue.h>
 #include <grpc++/impl/call.h>
-#include <grpc++/impl/sync.h>
 #include <grpc++/support/time.h>
 #include <grpc/compression.h>
 #include <grpc/grpc.h>
@@ -48,7 +49,7 @@ namespace grpc {
 
 // CompletionOp
 
-class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
+class ServerContext::CompletionOp final : public CallOpSetInterface {
  public:
   // initial refs: one in the server context, one in the cq
   CompletionOp()
@@ -58,8 +59,8 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
         finalized_(false),
         cancelled_(0) {}
 
-  void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE;
-  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE;
+  void FillOps(grpc_op* ops, size_t* nops) override;
+  bool FinalizeResult(void** tag, bool* status) override;
 
   bool CheckCancelled(CompletionQueue* cq) {
     cq->TryPluck(this);
@@ -76,20 +77,20 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface {
 
  private:
   bool CheckCancelledNoPluck() {
-    grpc::lock_guard<grpc::mutex> g(mu_);
+    std::lock_guard<std::mutex> g(mu_);
     return finalized_ ? (cancelled_ != 0) : false;
   }
 
   bool has_tag_;
   void* tag_;
-  grpc::mutex mu_;
+  std::mutex mu_;
   int refs_;
   bool finalized_;
   int cancelled_;
 };
 
 void ServerContext::CompletionOp::Unref() {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   if (--refs_ == 0) {
     lock.unlock();
     delete this;
@@ -105,7 +106,7 @@ void ServerContext::CompletionOp::FillOps(grpc_op* ops, size_t* nops) {
 }
 
 bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {
-  grpc::unique_lock<grpc::mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   finalized_ = true;
   bool ret = false;
   if (has_tag_) {
diff --git a/src/cpp/test/server_context_test_spouse.cc b/src/cpp/test/server_context_test_spouse.cc
new file mode 100644
index 0000000000..b93152eea0
--- /dev/null
+++ b/src/cpp/test/server_context_test_spouse.cc
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc++/test/server_context_test_spouse.h>
+
+namespace grpc {
+namespace testing {
+
+void ServerContextTestSpouse::AddClientMetadata(const grpc::string& key,
+                                                const grpc::string& value) {
+  client_metadata_storage_.insert(
+      std::pair<grpc::string, grpc::string>(key, value));
+  ctx_->client_metadata_.clear();
+  for (auto iter = client_metadata_storage_.begin();
+       iter != client_metadata_storage_.end(); ++iter) {
+    ctx_->client_metadata_.insert(std::pair<grpc::string_ref, grpc::string_ref>(
+        iter->first.c_str(), iter->second.c_str()));
+  }
+}
+
+}  // namespace testing
+}  // namespace grpc
diff --git a/src/cpp/thread_manager/thread_manager.cc b/src/cpp/thread_manager/thread_manager.cc
new file mode 100644
index 0000000000..1450d009e4
--- /dev/null
+++ b/src/cpp/thread_manager/thread_manager.cc
@@ -0,0 +1,182 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/cpp/thread_manager/thread_manager.h"
+
+#include <climits>
+#include <mutex>
+#include <thread>
+
+#include <grpc/support/log.h>
+
+namespace grpc {
+
+ThreadManager::WorkerThread::WorkerThread(ThreadManager* thd_mgr)
+    : thd_mgr_(thd_mgr), thd_(&ThreadManager::WorkerThread::Run, this) {}
+
+void ThreadManager::WorkerThread::Run() {
+  thd_mgr_->MainWorkLoop();
+  thd_mgr_->MarkAsCompleted(this);
+}
+
+ThreadManager::WorkerThread::~WorkerThread() { thd_.join(); }
+
+ThreadManager::ThreadManager(int min_pollers, int max_pollers)
+    : shutdown_(false),
+      num_pollers_(0),
+      min_pollers_(min_pollers),
+      max_pollers_(max_pollers == -1 ? INT_MAX : max_pollers),
+      num_threads_(0) {}
+
+ThreadManager::~ThreadManager() {
+  {
+    std::unique_lock<std::mutex> lock(mu_);
+    GPR_ASSERT(num_threads_ == 0);
+  }
+
+  CleanupCompletedThreads();
+}
+
+void ThreadManager::Wait() {
+  std::unique_lock<std::mutex> lock(mu_);
+  while (num_threads_ != 0) {
+    shutdown_cv_.wait(lock);
+  }
+}
+
+void ThreadManager::Shutdown() {
+  std::unique_lock<std::mutex> lock(mu_);
+  shutdown_ = true;
+}
+
+bool ThreadManager::IsShutdown() {
+  std::unique_lock<std::mutex> lock(mu_);
+  return shutdown_;
+}
+
+void ThreadManager::MarkAsCompleted(WorkerThread* thd) {
+  {
+    std::unique_lock<std::mutex> list_lock(list_mu_);
+    completed_threads_.push_back(thd);
+  }
+
+  std::unique_lock<std::mutex> lock(mu_);
+  num_threads_--;
+  if (num_threads_ == 0) {
+    shutdown_cv_.notify_one();
+  }
+}
+
+void ThreadManager::CleanupCompletedThreads() {
+  std::unique_lock<std::mutex> lock(list_mu_);
+  for (auto thd = completed_threads_.begin(); thd != completed_threads_.end();
+       thd = completed_threads_.erase(thd)) {
+    delete *thd;
+  }
+}
+
+void ThreadManager::Initialize() {
+  for (int i = 0; i < min_pollers_; i++) {
+    MaybeCreatePoller();
+  }
+}
+
+// If the number of pollers (i.e threads currently blocked in PollForWork()) is
+// less than max threshold (i.e max_pollers_) and the total number of threads is
+// below the maximum threshold, we can let the current thread continue as poller
+bool ThreadManager::MaybeContinueAsPoller() {
+  std::unique_lock<std::mutex> lock(mu_);
+  if (shutdown_ || num_pollers_ > max_pollers_) {
+    return false;
+  }
+
+  num_pollers_++;
+  return true;
+}
+
+// Create a new poller if the current number of pollers i.e num_pollers_ (i.e
+// threads currently blocked in PollForWork()) is below the threshold (i.e
+// min_pollers_) and the total number of threads is below the maximum threshold
+void ThreadManager::MaybeCreatePoller() {
+  std::unique_lock<std::mutex> lock(mu_);
+  if (!shutdown_ && num_pollers_ < min_pollers_) {
+    num_pollers_++;
+    num_threads_++;
+
+    // Create a new thread (which ends up calling the MainWorkLoop() function
+    new WorkerThread(this);
+  }
+}
+
+void ThreadManager::MainWorkLoop() {
+  void* tag;
+  bool ok;
+
+  /*
+   1. Poll for work (i.e PollForWork())
+   2. After returning from PollForWork, reduce the number of pollers by 1. If
+      PollForWork() returned a TIMEOUT, then it may indicate that we have more
+      polling threads than needed. Check if the number of pollers is greater
+      than min_pollers and if so, terminate the thread.
+   3. Since we are short of one poller now, see if a new poller has to be
+      created (i.e see MaybeCreatePoller() for more details)
+   4. Do the actual work (DoWork())
+   5. After doing the work, see it this thread can resume polling work (i.e
+      see MaybeContinueAsPoller() for more details) */
+  do {
+    WorkStatus work_status = PollForWork(&tag, &ok);
+
+    {
+      std::unique_lock<std::mutex> lock(mu_);
+      num_pollers_--;
+
+      if (work_status == TIMEOUT && num_pollers_ > min_pollers_) {
+        break;
+      }
+    }
+
+    // Note that MaybeCreatePoller does check for shutdown and creates a new
+    // thread only if ThreadManager is not shutdown
+    if (work_status == WORK_FOUND) {
+      MaybeCreatePoller();
+      DoWork(tag, ok);
+    }
+  } while (MaybeContinueAsPoller());
+
+  CleanupCompletedThreads();
+
+  // If we are here, either ThreadManager is shutting down or it already has
+  // enough threads.
+}
+
+}  // namespace grpc
diff --git a/src/cpp/thread_manager/thread_manager.h b/src/cpp/thread_manager/thread_manager.h
new file mode 100644
index 0000000000..9c0569c62c
--- /dev/null
+++ b/src/cpp/thread_manager/thread_manager.h
@@ -0,0 +1,160 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_CPP_THREAD_MANAGER_H
+#define GRPC_INTERNAL_CPP_THREAD_MANAGER_H
+
+#include <condition_variable>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+#include <grpc++/support/config.h>
+
+namespace grpc {
+
+class ThreadManager {
+ public:
+  explicit ThreadManager(int min_pollers, int max_pollers);
+  virtual ~ThreadManager();
+
+  // Initializes and Starts the Rpc Manager threads
+  void Initialize();
+
+  // The return type of PollForWork() function
+  enum WorkStatus { WORK_FOUND, SHUTDOWN, TIMEOUT };
+
+  // "Polls" for new work.
+  // If the return value is WORK_FOUND:
+  //  - The implementaion of PollForWork() MAY set some opaque identifier to
+  //    (identify the work item found) via the '*tag' parameter
+  //  - The implementaion MUST set the value of 'ok' to 'true' or 'false'. A
+  //    value of 'false' indicates some implemenation specific error (that is
+  //    neither SHUTDOWN nor TIMEOUT)
+  //  - ThreadManager does not interpret the values of 'tag' and 'ok'
+  //  - ThreadManager WILL call DoWork() and pass '*tag' and 'ok' as input to
+  //    DoWork()
+  //
+  // If the return value is SHUTDOWN:,
+  //  - ThreadManager WILL NOT call DoWork() and terminates the thead
+  //
+  // If the return value is TIMEOUT:,
+  //  - ThreadManager WILL NOT call DoWork()
+  //  - ThreadManager MAY terminate the thread depending on the current number
+  //    of active poller threads and mix_pollers/max_pollers settings
+  //  - Also, the value of timeout is specific to the derived class
+  //    implementation
+  virtual WorkStatus PollForWork(void** tag, bool* ok) = 0;
+
+  // The implementation of DoWork() is supposed to perform the work found by
+  // PollForWork(). The tag and ok parameters are the same as returned by
+  // PollForWork()
+  //
+  // The implementation of DoWork() should also do any setup needed to ensure
+  // that the next call to PollForWork() (not necessarily by the current thread)
+  // actually finds some work
+  virtual void DoWork(void* tag, bool ok) = 0;
+
+  // Mark the ThreadManager as shutdown and begin draining the work. This is a
+  // non-blocking call and the caller should call Wait(), a blocking call which
+  // returns only once the shutdown is complete
+  void Shutdown();
+
+  // Has Shutdown() been called
+  bool IsShutdown();
+
+  // A blocking call that returns only after the ThreadManager has shutdown and
+  // all the threads have drained all the outstanding work
+  void Wait();
+
+ private:
+  // Helper wrapper class around std::thread. This takes a ThreadManager object
+  // and starts a new std::thread to calls the Run() function.
+  //
+  // The Run() function calls ThreadManager::MainWorkLoop() function and once
+  // that completes, it marks the WorkerThread completed by calling
+  // ThreadManager::MarkAsCompleted()
+  class WorkerThread {
+   public:
+    WorkerThread(ThreadManager* thd_mgr);
+    ~WorkerThread();
+
+   private:
+    // Calls thd_mgr_->MainWorkLoop() and once that completes, calls
+    // thd_mgr_>MarkAsCompleted(this) to mark the thread as completed
+    void Run();
+
+    ThreadManager* thd_mgr_;
+    std::thread thd_;
+  };
+
+  // The main funtion in ThreadManager
+  void MainWorkLoop();
+
+  // Create a new poller if the number of current pollers is less than the
+  // minimum number of pollers needed (i.e min_pollers).
+  void MaybeCreatePoller();
+
+  // Returns true if the current thread can resume as a poller. i.e if the
+  // current number of pollers is less than the max_pollers.
+  bool MaybeContinueAsPoller();
+
+  void MarkAsCompleted(WorkerThread* thd);
+  void CleanupCompletedThreads();
+
+  // Protects shutdown_, num_pollers_ and num_threads_
+  // TODO: sreek - Change num_pollers and num_threads_ to atomics
+  std::mutex mu_;
+
+  bool shutdown_;
+  std::condition_variable shutdown_cv_;
+
+  // Number of threads doing polling
+  int num_pollers_;
+
+  // The minimum and maximum number of threads that should be doing polling
+  int min_pollers_;
+  int max_pollers_;
+
+  // The total number of threads (includes threads includes the threads that are
+  // currently polling i.e num_pollers_)
+  int num_threads_;
+
+  std::mutex list_mu_;
+  std::list<WorkerThread*> completed_threads_;
+};
+
+}  // namespace grpc
+
+#endif  // GRPC_INTERNAL_CPP_THREAD_MANAGER_H
diff --git a/src/cpp/util/byte_buffer_cc.cc b/src/cpp/util/byte_buffer_cc.cc
index 91ed66b766..cbe0aad26c 100644
--- a/src/cpp/util/byte_buffer_cc.cc
+++ b/src/cpp/util/byte_buffer_cc.cc
@@ -38,18 +38,18 @@ namespace grpc {
 
 ByteBuffer::ByteBuffer(const Slice* slices, size_t nslices) {
   // The following assertions check that the representation of a grpc::Slice is
-  // identical to that of a gpr_slice:  it has a gpr_slice field, and nothing
+  // identical to that of a grpc_slice:  it has a grpc_slice field, and nothing
   // else.
-  static_assert(std::is_same<decltype(slices[0].slice_), gpr_slice>::value,
-                "Slice must have same representation as gpr_slice");
-  static_assert(sizeof(Slice) == sizeof(gpr_slice),
-                "Slice must have same representation as gpr_slice");
+  static_assert(std::is_same<decltype(slices[0].slice_), grpc_slice>::value,
+                "Slice must have same representation as grpc_slice");
+  static_assert(sizeof(Slice) == sizeof(grpc_slice),
+                "Slice must have same representation as grpc_slice");
   // The const_cast is legal if grpc_raw_byte_buffer_create() does no more
   // than its advertised side effect of increasing the reference count of the
   // slices it processes, and such an increase does not affect the semantics
   // seen by the caller of this constructor.
   buffer_ = grpc_raw_byte_buffer_create(
-      reinterpret_cast<gpr_slice*>(const_cast<Slice*>(slices)), nslices);
+      reinterpret_cast<grpc_slice*>(const_cast<Slice*>(slices)), nslices);
 }
 
 ByteBuffer::~ByteBuffer() {
@@ -75,7 +75,7 @@ Status ByteBuffer::Dump(std::vector<Slice>* slices) const {
     return Status(StatusCode::INTERNAL,
                   "Couldn't initialize byte buffer reader");
   }
-  gpr_slice s;
+  grpc_slice s;
   while (grpc_byte_buffer_reader_next(&reader, &s)) {
     slices->push_back(Slice(s, Slice::STEAL_REF));
   }
diff --git a/src/cpp/util/slice_cc.cc b/src/cpp/util/slice_cc.cc
index 7e88423b6c..c05f1cf124 100644
--- a/src/cpp/util/slice_cc.cc
+++ b/src/cpp/util/slice_cc.cc
@@ -37,12 +37,12 @@ namespace grpc {
 
 Slice::Slice() : slice_(gpr_empty_slice()) {}
 
-Slice::~Slice() { gpr_slice_unref(slice_); }
+Slice::~Slice() { grpc_slice_unref(slice_); }
 
-Slice::Slice(gpr_slice slice, AddRef) : slice_(gpr_slice_ref(slice)) {}
+Slice::Slice(grpc_slice slice, AddRef) : slice_(grpc_slice_ref(slice)) {}
 
-Slice::Slice(gpr_slice slice, StealRef) : slice_(slice) {}
+Slice::Slice(grpc_slice slice, StealRef) : slice_(slice) {}
 
-Slice::Slice(const Slice& other) : slice_(gpr_slice_ref(other.slice_)) {}
+Slice::Slice(const Slice& other) : slice_(grpc_slice_ref(other.slice_)) {}
 
 }  // namespace grpc
diff --git a/src/cpp/util/time_cc.cc b/src/cpp/util/time_cc.cc
index c43d848cc6..cd59a19703 100644
--- a/src/cpp/util/time_cc.cc
+++ b/src/cpp/util/time_cc.cc
@@ -32,9 +32,6 @@
  */
 
 #include <grpc++/support/config.h>
-
-#ifndef GRPC_CXX0X_NO_CHRONO
-
 #include <grpc++/support/time.h>
 #include <grpc/support/time.h>
 
@@ -91,5 +88,3 @@ system_clock::time_point Timespec2Timepoint(gpr_timespec t) {
 }
 
 }  // namespace grpc
-
-#endif  // !GRPC_CXX0X_NO_CHRONO