Merge branch 'master' into untypedAPI

Makefile

@@ -159,9 +159,14 @@ ifndef VALID_CONFIG_$(CONFIG)
 $(error Invalid CONFIG value '$(CONFIG)')
 endif
 
+ifeq ($(SYSTEM),Linux)
+TMPOUT = /dev/null
+else
+TMPOUT = `mktemp /tmp/test-out-XXXXXX`
+endif
 
 # Detect if we can use C++11
-CXX11_CHECK_CMD = $(CXX) -std=c++11 -o /dev/null -c test/build/c++11.cc
+CXX11_CHECK_CMD = $(CXX) -std=c++11 -o $(TMPOUT) -c test/build/c++11.cc
 HAS_CXX11 = $(shell $(CXX11_CHECK_CMD) 2> /dev/null && echo true || echo false)
 
 # The HOST compiler settings are used to compile the protoc plugins.
@@ -194,9 +199,25 @@ LDFLAGS += -g -fPIC
 
 INCLUDES = . include $(GENDIR)
 ifeq ($(SYSTEM),Darwin)
-INCLUDES += /usr/local/ssl/include /opt/local/include
+ifneq ($(wildcard /usr/local/ssl/include),)
+INCLUDES += /usr/local/ssl/include
+endif
+ifneq ($(wildcard /opt/local/include),)
+INCLUDES += /opt/local/include
+endif
+ifneq ($(wildcard /usr/local/include),)
+INCLUDES += /usr/local/include
+endif
 LIBS = m z
-LDFLAGS += -L/usr/local/ssl/lib -L/opt/local/lib
+ifneq ($(wildcard /usr/local/ssl/lib),)
+LDFLAGS += -L/usr/local/ssl/lib
+endif
+ifneq ($(wildcard /opt/local/lib),)
+LDFLAGS += -L/opt/local/lib
+endif
+ifneq ($(wildcard /usr/local/lib),)
+LDFLAGS += -L/usr/local/lib
+endif
 else
 LIBS = rt m z pthread
 LDFLAGS += -pthread
@@ -251,10 +272,10 @@ else
 IS_GIT_FOLDER = true
 endif
 
-OPENSSL_ALPN_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o /dev/null test/build/openssl-alpn.c -lssl -lcrypto -ldl $(LDFLAGS)
-ZLIB_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o /dev/null test/build/zlib.c -lz $(LDFLAGS)
-PERFTOOLS_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o /dev/null test/build/perftools.c -lprofiler $(LDFLAGS)
-PROTOBUF_CHECK_CMD = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -o /dev/null test/build/protobuf.cc -lprotobuf $(LDFLAGS)
+OPENSSL_ALPN_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o $(TMPOUT) test/build/openssl-alpn.c -lssl -lcrypto -ldl $(LDFLAGS)
+ZLIB_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o $(TMPOUT) test/build/zlib.c -lz $(LDFLAGS)
+PERFTOOLS_CHECK_CMD = $(CC) $(CFLAGS) $(CPPFLAGS) -o $(TMPOUT) test/build/perftools.c -lprofiler $(LDFLAGS)
+PROTOBUF_CHECK_CMD = $(CXX) $(CXXFLAGS) $(CPPFLAGS) -o $(TMPOUT) test/build/protobuf.cc -lprotobuf $(LDFLAGS)
 PROTOC_CMD = which protoc
 PROTOC_CHECK_CMD = protoc --version | grep -q libprotoc.3
 
@@ -2039,10 +2060,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/gpr.$(SHARED_EXT) $(prefix)/lib/gpr.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgpr-imp.a $(prefix)/lib/libgpr-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgpr.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgpr.$(SHARED_EXT) $(prefix)/lib/libgpr.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgpr.$(SHARED_EXT) $(prefix)/lib/libgpr.so
 endif
 endif
@@ -2052,10 +2073,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/grpc.$(SHARED_EXT) $(prefix)/lib/grpc.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc-imp.a $(prefix)/lib/libgrpc-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgrpc.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc.$(SHARED_EXT) $(prefix)/lib/libgrpc.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgrpc.$(SHARED_EXT) $(prefix)/lib/libgrpc.so
 endif
 endif
@@ -2065,10 +2086,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/grpc_unsecure.$(SHARED_EXT) $(prefix)/lib/grpc_unsecure.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc_unsecure-imp.a $(prefix)/lib/libgrpc_unsecure-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgrpc_unsecure.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc_unsecure.$(SHARED_EXT) $(prefix)/lib/libgrpc_unsecure.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgrpc_unsecure.$(SHARED_EXT) $(prefix)/lib/libgrpc_unsecure.so
 endif
 endif
@@ -2086,10 +2107,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/grpc++.$(SHARED_EXT) $(prefix)/lib/grpc++.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc++-imp.a $(prefix)/lib/libgrpc++-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgrpc++.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc++.$(SHARED_EXT) $(prefix)/lib/libgrpc++.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgrpc++.$(SHARED_EXT) $(prefix)/lib/libgrpc++.so
 endif
 endif
@@ -2099,10 +2120,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/grpc++_unsecure.$(SHARED_EXT) $(prefix)/lib/grpc++_unsecure.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc++_unsecure-imp.a $(prefix)/lib/libgrpc++_unsecure-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgrpc++_unsecure.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc++_unsecure.$(SHARED_EXT) $(prefix)/lib/libgrpc++_unsecure.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgrpc++_unsecure.$(SHARED_EXT) $(prefix)/lib/libgrpc++_unsecure.so
 endif
 endif
@@ -2120,10 +2141,10 @@ ifeq ($(SYSTEM),MINGW32)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/grpc_csharp_ext.$(SHARED_EXT) $(prefix)/lib/grpc_csharp_ext.$(SHARED_EXT)
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc_csharp_ext-imp.a $(prefix)/lib/libgrpc_csharp_ext-imp.a
 else
+ifneq ($(SYSTEM),Darwin)
 	$(E) "[INSTALL] Installing libgrpc_csharp_ext.$(SHARED_EXT)"
 	$(Q) $(INSTALL) -d $(prefix)/lib
 	$(Q) $(INSTALL) $(LIBDIR)/$(CONFIG)/libgrpc_csharp_ext.$(SHARED_EXT) $(prefix)/lib/libgrpc_csharp_ext.$(SHARED_EXT)
-ifneq ($(SYSTEM),Darwin)
 	$(Q) ln -sf libgrpc_csharp_ext.$(SHARED_EXT) $(prefix)/lib/libgrpc_csharp_ext.so
 endif
 endif

include/grpc++/config.h

@@ -42,9 +42,9 @@
 #define GRPC_OVERRIDE override
 #endif
 
-#ifndef GRPC_CUSTOM_STRING
-#include <string>
-#define GRPC_CUSTOM_STRING std::string
+#ifndef GRPC_CUSTOM_PROTOBUF_INT64
+#include <google/protobuf/stubs/common.h>
+#define GRPC_CUSTOM_PROTOBUF_INT64 ::google::protobuf::int64
 #endif
 
 #ifndef GRPC_CUSTOM_MESSAGE
@@ -52,12 +52,32 @@
 #define GRPC_CUSTOM_MESSAGE ::google::protobuf::Message
 #endif
 
+#ifndef GRPC_CUSTOM_STRING
+#include <string>
+#define GRPC_CUSTOM_STRING std::string
+#endif
+
+#ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM
+#include <google/protobuf/io/zero_copy_stream.h>
+#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ::google::protobuf::io::ZeroCopyOutputStream
+#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ::google::protobuf::io::ZeroCopyInputStream
+#endif
+
+
 namespace grpc {
 
 typedef GRPC_CUSTOM_STRING string;
 
 namespace protobuf {
+
 typedef GRPC_CUSTOM_MESSAGE Message;
+typedef GRPC_CUSTOM_PROTOBUF_INT64 int64;
+
+namespace io {
+typedef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ZeroCopyOutputStream;
+typedef GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ZeroCopyInputStream;
+}  // namespace io
+
 }  // namespace protobuf
 
 }  // namespace grpc

include/grpc++/credentials.h

@@ -105,6 +105,14 @@ std::unique_ptr<Credentials> ServiceAccountCredentials(
     const grpc::string& json_key, const grpc::string& scope,
     std::chrono::seconds token_lifetime);
 
+// Builds JWT credentials.
+// json_key is the JSON key string containing the client's private key.
+// token_lifetime is the lifetime of each Json Web Token (JWT) created with
+// this credentials.  It should not exceed grpc_max_auth_token_lifetime or
+// will be cropped to this value.
+std::unique_ptr<Credentials> JWTCredentials(
+    const grpc::string& json_key, std::chrono::seconds token_lifetime);
+
 // Builds IAM credentials.
 std::unique_ptr<Credentials> IAMCredentials(
     const grpc::string& authorization_token,

include/grpc/grpc_security.h

@@ -117,6 +117,15 @@ grpc_credentials *grpc_service_account_credentials_create(
 grpc_credentials *grpc_jwt_credentials_create(const char *json_key,
                                               gpr_timespec token_lifetime);
 
+/* Creates an Oauth2 Refresh Token crednetials object. May return NULL if the
+   input is invalid.
+   WARNING: Do NOT use this credentials to connect to a non-google service as
+   this could result in an oauth2 token leak.
+   - json_refresh_token is the JSON string containing the refresh token itself
+     along with a client_id and client_secret. */
+grpc_credentials *grpc_refresh_token_credentials_create(
+    const char *json_refresh_token);
+
 /* Creates a fake transport security credentials object for testing. */
 grpc_credentials *grpc_fake_transport_security_credentials_create(void);
 

include/grpc/support/atm_gcc_atomic.h

@@ -43,6 +43,7 @@ typedef gpr_intptr gpr_atm;
 #define gpr_atm_full_barrier() (__atomic_thread_fence(__ATOMIC_SEQ_CST))
 
 #define gpr_atm_acq_load(p) (__atomic_load_n((p), __ATOMIC_ACQUIRE))
+#define gpr_atm_no_barrier_load(p) (__atomic_load_n((p), __ATOMIC_RELAXED))
 #define gpr_atm_rel_store(p, value) \
   (__atomic_store_n((p), (gpr_intptr)(value), __ATOMIC_RELEASE))
 

include/grpc/support/atm_gcc_sync.h

@@ -40,9 +40,11 @@
 
 typedef gpr_intptr gpr_atm;
 
+#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" : : : "memory")
+
 #if defined(__i386) || defined(__x86_64__)
 /* All loads are acquire loads and all stores are release stores.  */
-#define GPR_ATM_LS_BARRIER_() __asm__ __volatile__("" : : : "memory")
+#define GPR_ATM_LS_BARRIER_() GPR_ATM_COMPILE_BARRIER_()
 #else
 #define GPR_ATM_LS_BARRIER_() gpr_atm_full_barrier()
 #endif
@@ -55,12 +57,19 @@ static __inline gpr_atm gpr_atm_acq_load(const gpr_atm *p) {
   return value;
 }
 
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) {
+  gpr_atm value = *p;
+  GPR_ATM_COMPILE_BARRIER_();
+  return value;
+}
+
 static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) {
   GPR_ATM_LS_BARRIER_();
   *p = value;
 }
 
 #undef GPR_ATM_LS_BARRIER_
+#undef GPR_ATM_COMPILE_BARRIER_
 
 #define gpr_atm_no_barrier_fetch_add(p, delta) \
   gpr_atm_full_fetch_add((p), (delta))

include/grpc/support/atm_win32.h

@@ -49,6 +49,11 @@ static __inline gpr_atm gpr_atm_acq_load(const gpr_atm *p) {
   return result;
 }
 
+static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) {
+  /* TODO(dklempner): Can we implement something better here? */
+  gpr_atm_acq_load(p);
+}
+
 static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) {
   gpr_atm_full_barrier();
   *p = value;

src/compiler/config.h

@@ -0,0 +1,90 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef SRC_COMPILER_CONFIG_H
+#define SRC_COMPILER_CONFIG_H
+
+#include <grpc++/config.h>
+
+#ifndef GRPC_CUSTOM_DESCRIPTOR
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#define GRPC_CUSTOM_DESCRIPTOR ::google::protobuf::Descriptor
+#define GRPC_CUSTOM_FILEDESCRIPTOR ::google::protobuf::FileDescriptor
+#define GRPC_CUSTOM_METHODDESCRIPTOR ::google::protobuf::MethodDescriptor
+#define GRPC_CUSTOM_SERVICEDESCRIPTOR ::google::protobuf::ServiceDescriptor
+#endif
+
+#ifndef GRPC_CUSTOM_CODEGENERATOR
+#include <google/protobuf/compiler/code_generator.h>
+#define GRPC_CUSTOM_CODEGENERATOR ::google::protobuf::compiler::CodeGenerator
+#define GRPC_CUSTOM_GENERATORCONTEXT ::google::protobuf::compiler::GeneratorContext
+#endif
+
+#ifndef GRPC_CUSTOM_PRINTER
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#define GRPC_CUSTOM_PRINTER ::google::protobuf::io::Printer
+#define GRPC_CUSTOM_CODEDOUTPUTSTREAM ::google::protobuf::io::CodedOutputStream
+#define GRPC_CUSTOM_STRINGOUTPUTSTREAM ::google::protobuf::io::StringOutputStream
+#endif
+
+#ifndef GRPC_CUSTOM_PLUGINMAIN
+#include <google/protobuf/compiler/plugin.h>
+#define GRPC_CUSTOM_PLUGINMAIN ::google::protobuf::compiler::PluginMain
+#endif
+
+namespace grpc {
+namespace protobuf {
+typedef GRPC_CUSTOM_DESCRIPTOR Descriptor;
+typedef GRPC_CUSTOM_FILEDESCRIPTOR FileDescriptor;
+typedef GRPC_CUSTOM_METHODDESCRIPTOR MethodDescriptor;
+typedef GRPC_CUSTOM_SERVICEDESCRIPTOR ServiceDescriptor;
+namespace compiler {
+typedef GRPC_CUSTOM_CODEGENERATOR CodeGenerator;
+typedef GRPC_CUSTOM_GENERATORCONTEXT GeneratorContext;
+static inline int PluginMain(int argc, char* argv[],
+                             const CodeGenerator* generator) {
+  return GRPC_CUSTOM_PLUGINMAIN(argc, argv, generator);
+}
+}  // namespace compiler
+namespace io {
+typedef GRPC_CUSTOM_PRINTER Printer;
+typedef GRPC_CUSTOM_CODEDOUTPUTSTREAM CodedOutputStream;
+typedef GRPC_CUSTOM_STRINGOUTPUTSTREAM StringOutputStream;
+}  // namespace io
+}  // namespace protobuf
+}  // namespace grpc
+
+#endif  // SRC_COMPILER_CONFIG_H

src/compiler/cpp_generator.cc

@@ -31,45 +31,42 @@
  *
  */
 
-#include <string>
 #include <map>
 
 #include "src/compiler/cpp_generator.h"
-
 #include "src/compiler/cpp_generator_helpers.h"
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/descriptor.pb.h>
-#include <google/protobuf/io/printer.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+
+#include "src/compiler/config.h"
+
 #include <sstream>
 
 namespace grpc_cpp_generator {
 namespace {
 
 template <class T>
-std::string as_string(T x) {
+grpc::string as_string(T x) {
   std::ostringstream out;
   out << x;
   return out.str();
 }
 
-bool NoStreaming(const google::protobuf::MethodDescriptor *method) {
+bool NoStreaming(const grpc::protobuf::MethodDescriptor *method) {
   return !method->client_streaming() && !method->server_streaming();
 }
 
-bool ClientOnlyStreaming(const google::protobuf::MethodDescriptor *method) {
+bool ClientOnlyStreaming(const grpc::protobuf::MethodDescriptor *method) {
   return method->client_streaming() && !method->server_streaming();
 }
 
-bool ServerOnlyStreaming(const google::protobuf::MethodDescriptor *method) {
+bool ServerOnlyStreaming(const grpc::protobuf::MethodDescriptor *method) {
   return !method->client_streaming() && method->server_streaming();
 }
 
-bool BidiStreaming(const google::protobuf::MethodDescriptor *method) {
+bool BidiStreaming(const grpc::protobuf::MethodDescriptor *method) {
   return method->client_streaming() && method->server_streaming();
 }
 
-bool HasUnaryCalls(const google::protobuf::FileDescriptor *file) {
+bool HasUnaryCalls(const grpc::protobuf::FileDescriptor *file) {
   for (int i = 0; i < file->service_count(); i++) {
     for (int j = 0; j < file->service(i)->method_count(); j++) {
       if (NoStreaming(file->service(i)->method(j))) {
@@ -80,7 +77,7 @@ bool HasUnaryCalls(const google::protobuf::FileDescriptor *file) {
   return false;
 }
 
-bool HasClientOnlyStreaming(const google::protobuf::FileDescriptor *file) {
+bool HasClientOnlyStreaming(const grpc::protobuf::FileDescriptor *file) {
   for (int i = 0; i < file->service_count(); i++) {
     for (int j = 0; j < file->service(i)->method_count(); j++) {
       if (ClientOnlyStreaming(file->service(i)->method(j))) {
@@ -91,7 +88,7 @@ bool HasClientOnlyStreaming(const google::protobuf::FileDescriptor *file) {
   return false;
 }
 
-bool HasServerOnlyStreaming(const google::protobuf::FileDescriptor *file) {
+bool HasServerOnlyStreaming(const grpc::protobuf::FileDescriptor *file) {
   for (int i = 0; i < file->service_count(); i++) {
     for (int j = 0; j < file->service(i)->method_count(); j++) {
       if (ServerOnlyStreaming(file->service(i)->method(j))) {
@@ -102,7 +99,7 @@ bool HasServerOnlyStreaming(const google::protobuf::FileDescriptor *file) {
   return false;
 }
 
-bool HasBidiStreaming(const google::protobuf::FileDescriptor *file) {
+bool HasBidiStreaming(const grpc::protobuf::FileDescriptor *file) {
   for (int i = 0; i < file->service_count(); i++) {
     for (int j = 0; j < file->service(i)->method_count(); j++) {
       if (BidiStreaming(file->service(i)->method(j))) {
@@ -114,8 +111,8 @@ bool HasBidiStreaming(const google::protobuf::FileDescriptor *file) {
 }
 }  // namespace
 
-std::string GetHeaderIncludes(const google::protobuf::FileDescriptor *file) {
-  std::string temp =
+grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file) {
+  grpc::string temp =
       "#include <grpc++/impl/internal_stub.h>\n"
       "#include <grpc++/impl/service_type.h>\n"
       "#include <grpc++/status.h>\n"
@@ -161,7 +158,7 @@ std::string GetHeaderIncludes(const google::protobuf::FileDescriptor *file) {
   return temp;
 }
 
-std::string GetSourceIncludes() {
+grpc::string GetSourceIncludes() {
   return "#include <grpc++/async_unary_call.h>\n"
          "#include <grpc++/channel_interface.h>\n"
          "#include <grpc++/impl/client_unary_call.h>\n"
@@ -171,9 +168,9 @@ std::string GetSourceIncludes() {
          "#include <grpc++/stream.h>\n";
 }
 
-void PrintHeaderClientMethod(google::protobuf::io::Printer *printer,
-                             const google::protobuf::MethodDescriptor *method,
-                             std::map<std::string, std::string> *vars) {
+void PrintHeaderClientMethod(grpc::protobuf::io::Printer *printer,
+                             const grpc::protobuf::MethodDescriptor *method,
+                             std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -223,9 +220,9 @@ void PrintHeaderClientMethod(google::protobuf::io::Printer *printer,
 }
 
 void PrintHeaderServerMethodSync(
-    google::protobuf::io::Printer *printer,
-    const google::protobuf::MethodDescriptor *method,
-    std::map<std::string, std::string> *vars) {
+    grpc::protobuf::io::Printer *printer,
+    const grpc::protobuf::MethodDescriptor *method,
+    std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -258,9 +255,9 @@ void PrintHeaderServerMethodSync(
 }
 
 void PrintHeaderServerMethodAsync(
-    google::protobuf::io::Printer *printer,
-    const google::protobuf::MethodDescriptor *method,
-    std::map<std::string, std::string> *vars) {
+    grpc::protobuf::io::Printer *printer,
+    const grpc::protobuf::MethodDescriptor *method,
+    std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -294,9 +291,9 @@ void PrintHeaderServerMethodAsync(
   }
 }
 
-void PrintHeaderService(google::protobuf::io::Printer *printer,
-                        const google::protobuf::ServiceDescriptor *service,
-                        std::map<std::string, std::string> *vars) {
+void PrintHeaderService(grpc::protobuf::io::Printer *printer,
+                        const grpc::protobuf::ServiceDescriptor *service,
+                        std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Service"] = service->name();
 
   printer->Print(*vars,
@@ -356,11 +353,11 @@ void PrintHeaderService(google::protobuf::io::Printer *printer,
   printer->Print("};\n");
 }
 
-std::string GetHeaderServices(const google::protobuf::FileDescriptor *file) {
-  std::string output;
-  google::protobuf::io::StringOutputStream output_stream(&output);
-  google::protobuf::io::Printer printer(&output_stream, '$');
-  std::map<std::string, std::string> vars;
+grpc::string GetHeaderServices(const grpc::protobuf::FileDescriptor *file) {
+  grpc::string output;
+  grpc::protobuf::io::StringOutputStream output_stream(&output);
+  grpc::protobuf::io::Printer printer(&output_stream, '$');
+  std::map<grpc::string, grpc::string> vars;
 
   for (int i = 0; i < file->service_count(); ++i) {
     PrintHeaderService(&printer, file->service(i), &vars);
@@ -369,9 +366,9 @@ std::string GetHeaderServices(const google::protobuf::FileDescriptor *file) {
   return output;
 }
 
-void PrintSourceClientMethod(google::protobuf::io::Printer *printer,
-                             const google::protobuf::MethodDescriptor *method,
-                             std::map<std::string, std::string> *vars) {
+void PrintSourceClientMethod(grpc::protobuf::io::Printer *printer,
+                             const grpc::protobuf::MethodDescriptor *method,
+                             std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -485,9 +482,9 @@ void PrintSourceClientMethod(google::protobuf::io::Printer *printer,
   }
 }
 
-void PrintSourceServerMethod(google::protobuf::io::Printer *printer,
-                             const google::protobuf::MethodDescriptor *method,
-                             std::map<std::string, std::string> *vars) {
+void PrintSourceServerMethod(grpc::protobuf::io::Printer *printer,
+                             const grpc::protobuf::MethodDescriptor *method,
+                             std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -536,9 +533,9 @@ void PrintSourceServerMethod(google::protobuf::io::Printer *printer,
 }
 
 void PrintSourceServerAsyncMethod(
-    google::protobuf::io::Printer *printer,
-    const google::protobuf::MethodDescriptor *method,
-    std::map<std::string, std::string> *vars) {
+    grpc::protobuf::io::Printer *printer,
+    const grpc::protobuf::MethodDescriptor *method,
+    std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
   (*vars)["Request"] =
       grpc_cpp_generator::ClassName(method->input_type(), true);
@@ -590,9 +587,9 @@ void PrintSourceServerAsyncMethod(
   }
 }
 
-void PrintSourceService(google::protobuf::io::Printer *printer,
-                        const google::protobuf::ServiceDescriptor *service,
-                        std::map<std::string, std::string> *vars) {
+void PrintSourceService(grpc::protobuf::io::Printer *printer,
+                        const grpc::protobuf::ServiceDescriptor *service,
+                        std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Service"] = service->name();
 
   printer->Print(*vars, "static const char* $Service$_method_names[] = {\n");
@@ -640,7 +637,7 @@ void PrintSourceService(google::protobuf::io::Printer *printer,
       "}\n");
   printer->Print("service_ = new ::grpc::RpcService();\n");
   for (int i = 0; i < service->method_count(); ++i) {
-    const google::protobuf::MethodDescriptor *method = service->method(i);
+    const grpc::protobuf::MethodDescriptor *method = service->method(i);
     (*vars)["Idx"] = as_string(i);
     (*vars)["Method"] = method->name();
     (*vars)["Request"] =
@@ -705,11 +702,11 @@ void PrintSourceService(google::protobuf::io::Printer *printer,
   printer->Print("}\n\n");
 }
 
-std::string GetSourceServices(const google::protobuf::FileDescriptor *file) {
-  std::string output;
-  google::protobuf::io::StringOutputStream output_stream(&output);
-  google::protobuf::io::Printer printer(&output_stream, '$');
-  std::map<std::string, std::string> vars;
+grpc::string GetSourceServices(const grpc::protobuf::FileDescriptor *file) {
+  grpc::string output;
+  grpc::protobuf::io::StringOutputStream output_stream(&output);
+  grpc::protobuf::io::Printer printer(&output_stream, '$');
+  std::map<grpc::string, grpc::string> vars;
   // Package string is empty or ends with a dot. It is used to fully qualify
   // method names.
   vars["Package"] = file->package();

src/compiler/cpp_generator.h

@@ -34,27 +34,21 @@
 #ifndef GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H
 #define GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H
 
-#include <string>
-
-namespace google {
-namespace protobuf {
-class FileDescriptor;
-}  // namespace protobuf
-}  // namespace google
+#include "src/compiler/config.h"
 
 namespace grpc_cpp_generator {
 
 // Return the includes needed for generated header file.
-std::string GetHeaderIncludes(const google::protobuf::FileDescriptor *file);
+grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file);
 
 // Return the includes needed for generated source file.
-std::string GetSourceIncludes();
+grpc::string GetSourceIncludes();
 
 // Return the services for generated header file.
-std::string GetHeaderServices(const google::protobuf::FileDescriptor *file);
+grpc::string GetHeaderServices(const grpc::protobuf::FileDescriptor *file);
 
 // Return the services for generated source file.
-std::string GetSourceServices(const google::protobuf::FileDescriptor *file);
+grpc::string GetSourceServices(const grpc::protobuf::FileDescriptor *file);
 
 }  // namespace grpc_cpp_generator
 

src/compiler/cpp_generator_helpers.h

@@ -35,30 +35,28 @@
 #define GRPC_INTERNAL_COMPILER_CPP_GENERATOR_HELPERS_H
 
 #include <map>
-#include <string>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/descriptor.pb.h>
+#include "src/compiler/config.h"
 #include "src/compiler/generator_helpers.h"
 
 namespace grpc_cpp_generator {
 
-inline std::string DotsToColons(const std::string &name) {
+inline grpc::string DotsToColons(const grpc::string &name) {
   return grpc_generator::StringReplace(name, ".", "::");
 }
 
-inline std::string DotsToUnderscores(const std::string &name) {
+inline grpc::string DotsToUnderscores(const grpc::string &name) {
   return grpc_generator::StringReplace(name, ".", "_");
 }
 
-inline std::string ClassName(const google::protobuf::Descriptor *descriptor,
-                             bool qualified) {
+inline grpc::string ClassName(const grpc::protobuf::Descriptor *descriptor,
+                              bool qualified) {
   // Find "outer", the descriptor of the top-level message in which
   // "descriptor" is embedded.
-  const google::protobuf::Descriptor *outer = descriptor;
+  const grpc::protobuf::Descriptor *outer = descriptor;
   while (outer->containing_type() != NULL) outer = outer->containing_type();
 
-  const std::string &outer_name = outer->full_name();
-  std::string inner_name = descriptor->full_name().substr(outer_name.size());
+  const grpc::string &outer_name = outer->full_name();
+  grpc::string inner_name = descriptor->full_name().substr(outer_name.size());
 
   if (qualified) {
     return "::" + DotsToColons(outer_name) + DotsToUnderscores(inner_name);

src/compiler/cpp_plugin.cc

@@ -35,26 +35,21 @@
 //
 
 #include <memory>
-#include <string>
+
+#include "src/compiler/config.h"
 
 #include "src/compiler/cpp_generator.h"
 #include "src/compiler/cpp_generator_helpers.h"
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/descriptor.pb.h>
-#include <google/protobuf/compiler/code_generator.h>
-#include <google/protobuf/compiler/plugin.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream.h>
 
-class CppGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
+class CppGrpcGenerator : public grpc::protobuf::compiler::CodeGenerator {
  public:
   CppGrpcGenerator() {}
   virtual ~CppGrpcGenerator() {}
 
-  virtual bool Generate(const google::protobuf::FileDescriptor *file,
-                        const std::string &parameter,
-                        google::protobuf::compiler::GeneratorContext *context,
-                        std::string *error) const {
+  virtual bool Generate(const grpc::protobuf::FileDescriptor *file,
+                        const grpc::string &parameter,
+                        grpc::protobuf::compiler::GeneratorContext *context,
+                        grpc::string *error) const {
     if (file->options().cc_generic_services()) {
       *error =
           "cpp grpc proto compiler plugin does not work with generic "
@@ -63,7 +58,7 @@ class CppGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
       return false;
     }
 
-    std::string file_name = grpc_generator::StripProto(file->name());
+    grpc::string file_name = grpc_generator::StripProto(file->name());
 
     // Generate .pb.h
     Insert(context, file_name + ".pb.h", "includes",
@@ -81,17 +76,17 @@ class CppGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
 
  private:
   // Insert the given code into the given file at the given insertion point.
-  void Insert(google::protobuf::compiler::GeneratorContext *context,
-              const std::string &filename, const std::string &insertion_point,
-              const std::string &code) const {
-    std::unique_ptr<google::protobuf::io::ZeroCopyOutputStream> output(
+  void Insert(grpc::protobuf::compiler::GeneratorContext *context,
+              const grpc::string &filename, const grpc::string &insertion_point,
+              const grpc::string &code) const {
+    std::unique_ptr<grpc::protobuf::io::ZeroCopyOutputStream> output(
         context->OpenForInsert(filename, insertion_point));
-    google::protobuf::io::CodedOutputStream coded_out(output.get());
+    grpc::protobuf::io::CodedOutputStream coded_out(output.get());
     coded_out.WriteRaw(code.data(), code.size());
   }
 };
 
 int main(int argc, char *argv[]) {
   CppGrpcGenerator generator;
-  return google::protobuf::compiler::PluginMain(argc, argv, &generator);
+  return grpc::protobuf::compiler::PluginMain(argc, argv, &generator);
 }

src/compiler/generator_helpers.h

@@ -35,14 +35,15 @@
 #define GRPC_INTERNAL_COMPILER_GENERATOR_HELPERS_H
 
 #include <map>
-#include <string>
+
+#include "src/compiler/config.h"
 
 namespace grpc_generator {
 
-inline bool StripSuffix(std::string *filename, const std::string &suffix) {
+inline bool StripSuffix(grpc::string *filename, const grpc::string &suffix) {
   if (filename->length() >= suffix.length()) {
     size_t suffix_pos = filename->length() - suffix.length();
-    if (filename->compare(suffix_pos, std::string::npos, suffix) == 0) {
+    if (filename->compare(suffix_pos, grpc::string::npos, suffix) == 0) {
       filename->resize(filename->size() - suffix.size());
       return true;
     }
@@ -51,20 +52,20 @@ inline bool StripSuffix(std::string *filename, const std::string &suffix) {
   return false;
 }
 
-inline std::string StripProto(std::string filename) {
+inline grpc::string StripProto(grpc::string filename) {
   if (!StripSuffix(&filename, ".protodevel")) {
     StripSuffix(&filename, ".proto");
   }
   return filename;
 }
 
-inline std::string StringReplace(std::string str, const std::string &from,
-                                 const std::string &to) {
+inline grpc::string StringReplace(grpc::string str, const grpc::string &from,
+                                  const grpc::string &to) {
   size_t pos = 0;
 
   for (;;) {
     pos = str.find(from, pos);
-    if (pos == std::string::npos) {
+    if (pos == grpc::string::npos) {
       break;
     }
     str.replace(pos, from.length(), to);

src/compiler/python_generator.cc

@@ -60,8 +60,6 @@ using std::make_pair;
 using std::map;
 using std::pair;
 using std::replace;
-using std::string;
-using std::strlen;
 using std::vector;
 
 namespace grpc_python_generator {
@@ -72,14 +70,14 @@ namespace {
 
 // Converts an initializer list of the form { key0, value0, key1, value1, ... }
 // into a map of key* to value*. Is merely a readability helper for later code.
-map<string, string> ListToDict(const initializer_list<string>& values) {
+map<std::string, std::string> ListToDict(const initializer_list<std::string>& values) {
   assert(values.size() % 2 == 0);
-  map<string, string> value_map;
+  map<std::string, std::string> value_map;
   auto value_iter = values.begin();
   for (unsigned i = 0; i < values.size()/2; ++i) {
-    string key = *value_iter;
+    std::string key = *value_iter;
     ++value_iter;
-    string value = *value_iter;
+    std::string value = *value_iter;
     value_map[key] = value;
     ++value_iter;
   }
@@ -113,8 +111,8 @@ class IndentScope {
 
 bool PrintServicer(const ServiceDescriptor* service,
                    Printer* out) {
-  string doc = "<fill me in later!>";
-  map<string, string> dict = ListToDict({
+  std::string doc = "<fill me in later!>";
+  map<std::string, std::string> dict = ListToDict({
         "Service", service->name(),
         "Documentation", doc,
       });
@@ -125,7 +123,7 @@ bool PrintServicer(const ServiceDescriptor* service,
     out->Print("__metaclass__ = abc.ABCMeta\n");
     for (int i = 0; i < service->method_count(); ++i) {
       auto meth = service->method(i);
-      string arg_name = meth->client_streaming() ?
+      std::string arg_name = meth->client_streaming() ?
           "request_iterator" : "request";
       out->Print("@abc.abstractmethod\n");
       out->Print("def $Method$(self, $ArgName$, context):\n",
@@ -140,8 +138,8 @@ bool PrintServicer(const ServiceDescriptor* service,
 }
 
 bool PrintServer(const ServiceDescriptor* service, Printer* out) {
-  string doc = "<fill me in later!>";
-  map<string, string> dict = ListToDict({
+  std::string doc = "<fill me in later!>";
+  map<std::string, std::string> dict = ListToDict({
         "Service", service->name(),
         "Documentation", doc,
       });
@@ -169,8 +167,8 @@ bool PrintServer(const ServiceDescriptor* service, Printer* out) {
 
 bool PrintStub(const ServiceDescriptor* service,
                Printer* out) {
-  string doc = "<fill me in later!>";
-  map<string, string> dict = ListToDict({
+  std::string doc = "<fill me in later!>";
+  map<std::string, std::string> dict = ListToDict({
         "Service", service->name(),
         "Documentation", doc,
       });
@@ -181,7 +179,7 @@ bool PrintStub(const ServiceDescriptor* service,
     out->Print("__metaclass__ = abc.ABCMeta\n");
     for (int i = 0; i < service->method_count(); ++i) {
       const MethodDescriptor* meth = service->method(i);
-      string arg_name = meth->client_streaming() ?
+      std::string arg_name = meth->client_streaming() ?
           "request_iterator" : "request";
       auto methdict = ListToDict({"Method", meth->name(), "ArgName", arg_name});
       out->Print("@abc.abstractmethod\n");
@@ -198,29 +196,29 @@ bool PrintStub(const ServiceDescriptor* service,
 
 // TODO(protobuf team): Export `ModuleName` from protobuf's
 // `src/google/protobuf/compiler/python/python_generator.cc` file.
-string ModuleName(const string& filename) {
-  string basename = StripProto(filename);
+std::string ModuleName(const std::string& filename) {
+  std::string basename = StripProto(filename);
   basename = StringReplace(basename, "-", "_");
   basename = StringReplace(basename, "/", ".");
   return basename + "_pb2";
 }
 
 bool GetModuleAndMessagePath(const Descriptor* type,
-                             pair<string, string>* out) {
+                             pair<std::string, std::string>* out) {
   const Descriptor* path_elem_type = type;
   vector<const Descriptor*> message_path;
   do {
     message_path.push_back(path_elem_type);
     path_elem_type = path_elem_type->containing_type();
   } while (path_elem_type != nullptr);
-  string file_name = type->file()->name();
+  std::string file_name = type->file()->name();
   static const int proto_suffix_length = strlen(".proto");
   if (!(file_name.size() > static_cast<size_t>(proto_suffix_length) &&
         file_name.find_last_of(".proto") == file_name.size() - 1)) {
     return false;
   }
-  string module = ModuleName(file_name);
-  string message_type;
+  std::string module = ModuleName(file_name);
+  std::string message_type;
   for (auto path_iter = message_path.rbegin();
        path_iter != message_path.rend(); ++path_iter) {
     message_type += (*path_iter)->name() + ".";
@@ -237,21 +235,21 @@ bool PrintServerFactory(const ServiceDescriptor* service, Printer* out) {
              "Service", service->name());
   {
     IndentScope raii_create_server_indent(out);
-    map<string, string> method_description_constructors;
-    map<string, pair<string, string>> input_message_modules_and_classes;
-    map<string, pair<string, string>> output_message_modules_and_classes;
+    map<std::string, std::string> method_description_constructors;
+    map<std::string, pair<std::string, std::string>> input_message_modules_and_classes;
+    map<std::string, pair<std::string, std::string>> output_message_modules_and_classes;
     for (int i = 0; i < service->method_count(); ++i) {
       const MethodDescriptor* method = service->method(i);
-      const string method_description_constructor =
-          string(method->client_streaming() ? "stream_" : "unary_") +
-          string(method->server_streaming() ? "stream_" : "unary_") +
+      const std::string method_description_constructor =
+          std::string(method->client_streaming() ? "stream_" : "unary_") +
+          std::string(method->server_streaming() ? "stream_" : "unary_") +
           "service_description";
-      pair<string, string> input_message_module_and_class;
+      pair<std::string, std::string> input_message_module_and_class;
       if (!GetModuleAndMessagePath(method->input_type(),
                                    &input_message_module_and_class)) {
         return false;
       }
-      pair<string, string> output_message_module_and_class;
+      pair<std::string, std::string> output_message_module_and_class;
       if (!GetModuleAndMessagePath(method->output_type(),
                                    &output_message_module_and_class)) {
         return false;
@@ -272,7 +270,7 @@ bool PrintServerFactory(const ServiceDescriptor* service, Printer* out) {
     for (auto& name_and_description_constructor :
          method_description_constructors) {
       IndentScope raii_descriptions_indent(out);
-      const string method_name = name_and_description_constructor.first;
+      const std::string method_name = name_and_description_constructor.first;
       auto input_message_module_and_class =
           input_message_modules_and_classes.find(method_name);
       auto output_message_module_and_class =
@@ -306,27 +304,27 @@ bool PrintServerFactory(const ServiceDescriptor* service, Printer* out) {
 }
 
 bool PrintStubFactory(const ServiceDescriptor* service, Printer* out) {
-  map<string, string> dict = ListToDict({
+  map<std::string, std::string> dict = ListToDict({
         "Service", service->name(),
       });
   out->Print(dict, "def early_adopter_create_$Service$_stub(host, port):\n");
   {
     IndentScope raii_create_server_indent(out);
-    map<string, string> method_description_constructors;
-    map<string, pair<string, string>> input_message_modules_and_classes;
-    map<string, pair<string, string>> output_message_modules_and_classes;
+    map<std::string, std::string> method_description_constructors;
+    map<std::string, pair<std::string, std::string>> input_message_modules_and_classes;
+    map<std::string, pair<std::string, std::string>> output_message_modules_and_classes;
     for (int i = 0; i < service->method_count(); ++i) {
       const MethodDescriptor* method = service->method(i);
-      const string method_description_constructor =
-          string(method->client_streaming() ? "stream_" : "unary_") +
-          string(method->server_streaming() ? "stream_" : "unary_") +
+      const std::string method_description_constructor =
+          std::string(method->client_streaming() ? "stream_" : "unary_") +
+          std::string(method->server_streaming() ? "stream_" : "unary_") +
           "invocation_description";
-      pair<string, string> input_message_module_and_class;
+      pair<std::string, std::string> input_message_module_and_class;
       if (!GetModuleAndMessagePath(method->input_type(),
                                    &input_message_module_and_class)) {
         return false;
       }
-      pair<string, string> output_message_module_and_class;
+      pair<std::string, std::string> output_message_module_and_class;
       if (!GetModuleAndMessagePath(method->output_type(),
                                    &output_message_module_and_class)) {
         return false;
@@ -347,7 +345,7 @@ bool PrintStubFactory(const ServiceDescriptor* service, Printer* out) {
     for (auto& name_and_description_constructor :
          method_description_constructors) {
       IndentScope raii_descriptions_indent(out);
-      const string method_name = name_and_description_constructor.first;
+      const std::string method_name = name_and_description_constructor.first;
       auto input_message_module_and_class =
           input_message_modules_and_classes.find(method_name);
       auto output_message_module_and_class =
@@ -385,8 +383,8 @@ bool PrintPreamble(const FileDescriptor* file, Printer* out) {
 
 }  // namespace
 
-pair<bool, string> GetServices(const FileDescriptor* file) {
-  string output;
+pair<bool, std::string> GetServices(const FileDescriptor* file) {
+  std::string output;
   {
     // Scope the output stream so it closes and finalizes output to the string.
     StringOutputStream output_stream(&output);

src/compiler/python_plugin.cc

@@ -51,18 +51,16 @@ using google::protobuf::compiler::GeneratorContext;
 using google::protobuf::compiler::PluginMain;
 using google::protobuf::io::CodedOutputStream;
 using google::protobuf::io::ZeroCopyOutputStream;
-using std::string;
-using std::strlen;
 
 class PythonGrpcGenerator : public CodeGenerator {
  public:
   PythonGrpcGenerator() {}
   ~PythonGrpcGenerator() {}
 
-  bool Generate(const FileDescriptor* file, const string& parameter,
-                GeneratorContext* context, string* error) const {
+  bool Generate(const FileDescriptor* file, const std::string& parameter,
+                GeneratorContext* context, std::string* error) const {
     // Get output file name.
-    string file_name;
+    std::string file_name;
     static const int proto_suffix_length = strlen(".proto");
     if (file->name().size() > static_cast<size_t>(proto_suffix_length) &&
         file->name().find_last_of(".proto") == file->name().size() - 1) {
@@ -77,7 +75,7 @@ class PythonGrpcGenerator : public CodeGenerator {
         context->OpenForInsert(file_name, "module_scope"));
     CodedOutputStream coded_out(output.get());
     bool success = false;
-    string code = "";
+    std::string code = "";
     tie(success, code) = grpc_python_generator::GetServices(file);
     if (success) {
       coded_out.WriteRaw(code.data(), code.size());

src/core/channel/metadata_buffer.c

@@ -147,54 +147,3 @@ void grpc_metadata_buffer_flush(grpc_metadata_buffer *buffer,
   gpr_free(impl);
   *buffer = NULL;
 }
-
-size_t grpc_metadata_buffer_count(const grpc_metadata_buffer *buffer) {
-  return *buffer ? (*buffer)->elems : 0;
-}
-
-typedef struct {
-  grpc_metadata_buffer_impl *impl;
-} elems_hdr;
-
-grpc_metadata *grpc_metadata_buffer_extract_elements(
-    grpc_metadata_buffer *buffer) {
-  grpc_metadata_buffer_impl *impl;
-  elems_hdr *hdr;
-  qelem *src;
-  grpc_metadata *out;
-  size_t i;
-
-  impl = *buffer;
-
-  if (!impl) {
-    return NULL;
-  }
-
-  hdr = gpr_malloc(sizeof(elems_hdr) + impl->elems * sizeof(grpc_metadata));
-  src = ELEMS(impl);
-  out = (grpc_metadata *)(hdr + 1);
-
-  hdr->impl = impl;
-  for (i = 0; i < impl->elems; i++) {
-    out[i].key = (char *)grpc_mdstr_as_c_string(src[i].md->key);
-    out[i].value = (char *)grpc_mdstr_as_c_string(src[i].md->value);
-    out[i].value_length = GPR_SLICE_LENGTH(src[i].md->value->slice);
-  }
-
-  /* clear out buffer (it's not possible to extract elements twice */
-  *buffer = NULL;
-
-  return out;
-}
-
-void grpc_metadata_buffer_cleanup_elements(void *elements,
-                                           grpc_op_error error) {
-  elems_hdr *hdr = ((elems_hdr *)elements) - 1;
-
-  if (!elements) {
-    return;
-  }
-
-  grpc_metadata_buffer_destroy(&hdr->impl, error);
-  gpr_free(hdr);
-}

src/core/iomgr/fd_posix.c

@@ -210,7 +210,7 @@ static void notify_on(grpc_fd *fd, gpr_atm *st, grpc_iomgr_closure *closure,
     /* swap was unsuccessful due to an intervening set_ready call.
        Fall through to the READY code below */
     case READY:
-      assert(gpr_atm_acq_load(st) == READY);
+      assert(gpr_atm_no_barrier_load(st) == READY);
       gpr_atm_rel_store(st, NOT_READY);
       make_callback(closure->cb, closure->cb_arg,
                     !gpr_atm_acq_load(&fd->shutdown),
@@ -245,8 +245,8 @@ static void set_ready_locked(gpr_atm *st, grpc_iomgr_closure *callbacks,
          Fall through to the WAITING code below */
       state = gpr_atm_acq_load(st);
     default: /* waiting */
-      assert(gpr_atm_acq_load(st) != READY &&
-             gpr_atm_acq_load(st) != NOT_READY);
+      assert(gpr_atm_no_barrier_load(st) != READY &&
+             gpr_atm_no_barrier_load(st) != NOT_READY);
       callbacks[(*ncallbacks)++] = *(grpc_iomgr_closure *)state;
       gpr_atm_rel_store(st, NOT_READY);
       return;
@@ -271,7 +271,7 @@ void grpc_fd_shutdown(grpc_fd *fd) {
   grpc_iomgr_closure cb[2];
   size_t ncb = 0;
   gpr_mu_lock(&fd->set_state_mu);
-  GPR_ASSERT(!gpr_atm_acq_load(&fd->shutdown));
+  GPR_ASSERT(!gpr_atm_no_barrier_load(&fd->shutdown));
   gpr_atm_rel_store(&fd->shutdown, 1);
   set_ready_locked(&fd->readst, cb, &ncb);
   set_ready_locked(&fd->writest, cb, &ncb);

src/core/security/credentials.c

@@ -46,20 +46,6 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-/* -- Constants. -- */
-
-#define GRPC_SECURE_TOKEN_REFRESH_THRESHOLD_SECS 60
-
-#define GRPC_COMPUTE_ENGINE_METADATA_HOST "metadata"
-#define GRPC_COMPUTE_ENGINE_METADATA_TOKEN_PATH \
-  "/computeMetadata/v1/instance/service-accounts/default/token"
-
-#define GRPC_SERVICE_ACCOUNT_HOST "www.googleapis.com"
-#define GRPC_SERVICE_ACCOUNT_TOKEN_PATH "/oauth2/v3/token"
-#define GRPC_SERVICE_ACCOUNT_POST_BODY_PREFIX                         \
-  "grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&" \
-  "assertion="
-
 /* -- Common. -- */
 
 typedef struct {
@@ -671,8 +657,8 @@ static void service_account_fetch_oauth2(
   }
   gpr_asprintf(&body, "%s%s", GRPC_SERVICE_ACCOUNT_POST_BODY_PREFIX, jwt);
   memset(&request, 0, sizeof(grpc_httpcli_request));
-  request.host = GRPC_SERVICE_ACCOUNT_HOST;
-  request.path = GRPC_SERVICE_ACCOUNT_TOKEN_PATH;
+  request.host = GRPC_GOOGLE_OAUTH2_SERVICE_HOST;
+  request.path = GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH;
   request.hdr_count = 1;
   request.hdrs = &header;
   request.use_ssl = 1;
@@ -703,6 +689,67 @@ grpc_credentials *grpc_service_account_credentials_create(
   return &c->base.base;
 }
 
+/* -- RefreshToken credentials. -- */
+
+typedef struct {
+  grpc_oauth2_token_fetcher_credentials base;
+  grpc_auth_refresh_token refresh_token;
+} grpc_refresh_token_credentials;
+
+static void refresh_token_destroy(grpc_credentials *creds) {
+  grpc_refresh_token_credentials *c =
+      (grpc_refresh_token_credentials *)creds;
+  grpc_auth_refresh_token_destruct(&c->refresh_token);
+  oauth2_token_fetcher_destroy(&c->base.base);
+}
+
+static grpc_credentials_vtable refresh_token_vtable = {
+    refresh_token_destroy, oauth2_token_fetcher_has_request_metadata,
+    oauth2_token_fetcher_has_request_metadata_only,
+    oauth2_token_fetcher_get_request_metadata};
+
+static void refresh_token_fetch_oauth2(
+    grpc_credentials_metadata_request *metadata_req,
+    grpc_httpcli_response_cb response_cb, gpr_timespec deadline) {
+  grpc_refresh_token_credentials *c =
+      (grpc_refresh_token_credentials *)metadata_req->creds;
+  grpc_httpcli_header header = {"Content-Type",
+                                "application/x-www-form-urlencoded"};
+  grpc_httpcli_request request;
+  char *body = NULL;
+  gpr_asprintf(&body, GRPC_REFRESH_TOKEN_POST_BODY_FORMAT_STRING,
+               c->refresh_token.client_id, c->refresh_token.client_secret,
+               c->refresh_token.refresh_token);
+  memset(&request, 0, sizeof(grpc_httpcli_request));
+  request.host = GRPC_GOOGLE_OAUTH2_SERVICE_HOST;
+  request.path = GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH;
+  request.hdr_count = 1;
+  request.hdrs = &header;
+  request.use_ssl = 1;
+  grpc_httpcli_post(&request, body, strlen(body), deadline, response_cb,
+                    metadata_req);
+  gpr_free(body);
+}
+
+grpc_credentials *grpc_refresh_token_credentials_create(
+    const char *json_refresh_token) {
+  grpc_refresh_token_credentials *c;
+  grpc_auth_refresh_token refresh_token =
+      grpc_auth_refresh_token_create_from_string(json_refresh_token);
+
+  if (!grpc_auth_refresh_token_is_valid(&refresh_token)) {
+    gpr_log(GPR_ERROR,
+            "Invalid input for refresh token credentials creation");
+    return NULL;
+  }
+  c = gpr_malloc(sizeof(grpc_refresh_token_credentials));
+  memset(c, 0, sizeof(grpc_refresh_token_credentials));
+  init_oauth2_token_fetcher(&c->base, refresh_token_fetch_oauth2);
+  c->base.base.vtable = &refresh_token_vtable;
+  c->refresh_token = refresh_token;
+  return &c->base.base;
+}
+
 /* -- Fake Oauth2 credentials. -- */
 
 typedef struct {

src/core/security/credentials.h

@@ -64,6 +64,22 @@ typedef enum {
 #define GRPC_GOOGLE_WELL_KNOWN_CREDENTIALS_FILE \
   "application_default_credentials.json"
 
+#define GRPC_SECURE_TOKEN_REFRESH_THRESHOLD_SECS 60
+
+#define GRPC_COMPUTE_ENGINE_METADATA_HOST "metadata"
+#define GRPC_COMPUTE_ENGINE_METADATA_TOKEN_PATH \
+  "/computeMetadata/v1/instance/service-accounts/default/token"
+
+#define GRPC_GOOGLE_OAUTH2_SERVICE_HOST "www.googleapis.com"
+#define GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH "/oauth2/v3/token"
+
+#define GRPC_SERVICE_ACCOUNT_POST_BODY_PREFIX                         \
+  "grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&" \
+  "assertion="
+
+#define GRPC_REFRESH_TOKEN_POST_BODY_FORMAT_STRING \
+  "client_id=%s&client_secret=%s&refresh_token=%s&grant_type=refresh_token"
+
 /* --- grpc_credentials. --- */
 
 /* It is the caller's responsibility to gpr_free the result if not NULL. */

src/core/security/google_default_credentials.c

@@ -138,6 +138,23 @@ static grpc_credentials *create_jwt_creds_from_path(char *creds_path) {
   return result;
 }
 
+/* Takes ownership of creds_path if not NULL. */
+static grpc_credentials *create_refresh_token_creds_from_path(
+    char *creds_path) {
+  grpc_credentials *result = NULL;
+  gpr_slice creds_data;
+  int file_ok = 0;
+  if (creds_path == NULL) return NULL;
+  creds_data = gpr_load_file(creds_path, &file_ok);
+  gpr_free(creds_path);
+  if (file_ok) {
+    result = grpc_refresh_token_credentials_create(
+        (const char *)GPR_SLICE_START_PTR(creds_data));
+    gpr_slice_unref(creds_data);
+  }
+  return result;
+}
+
 grpc_credentials *grpc_google_default_credentials_create(void) {
   grpc_credentials *result = NULL;
   int serving_cached_credentials = 0;
@@ -157,7 +174,7 @@ grpc_credentials *grpc_google_default_credentials_create(void) {
   if (result != NULL) goto end;
 
   /* Then the well-known file. */
-  result = create_jwt_creds_from_path(
+  result = create_refresh_token_creds_from_path(
       grpc_get_well_known_google_credentials_file_path());
   if (result != NULL) goto end;
 

src/core/security/json_token.c

@@ -52,8 +52,9 @@
 /* 1 hour max. */
 const gpr_timespec grpc_max_auth_token_lifetime = {3600, 0};
 
-#define GRPC_AUTH_JSON_KEY_TYPE_INVALID "invalid"
-#define GRPC_AUTH_JSON_KEY_TYPE_SERVICE_ACCOUNT "service_account"
+#define GRPC_AUTH_JSON_TYPE_INVALID "invalid"
+#define GRPC_AUTH_JSON_TYPE_SERVICE_ACCOUNT "service_account"
+#define GRPC_AUTH_JSON_TYPE_AUTHORIZED_USER "authorized_user"
 
 #define GRPC_JWT_RSA_SHA256_ALGORITHM "RS256"
 #define GRPC_JWT_TYPE "JWT"
@@ -87,7 +88,7 @@ static int set_json_key_string_property(grpc_json *json, const char *prop_name,
 
 int grpc_auth_json_key_is_valid(const grpc_auth_json_key *json_key) {
   return (json_key != NULL) &&
-         strcmp(json_key->type, GRPC_AUTH_JSON_KEY_TYPE_INVALID);
+         strcmp(json_key->type, GRPC_AUTH_JSON_TYPE_INVALID);
 }
 
 grpc_auth_json_key grpc_auth_json_key_create_from_string(
@@ -100,7 +101,7 @@ grpc_auth_json_key grpc_auth_json_key_create_from_string(
   int success = 0;
 
   memset(&result, 0, sizeof(grpc_auth_json_key));
-  result.type = GRPC_AUTH_JSON_KEY_TYPE_INVALID;
+  result.type = GRPC_AUTH_JSON_TYPE_INVALID;
   if (json == NULL) {
     gpr_log(GPR_ERROR, "Invalid json string %s", json_string);
     goto end;
@@ -108,10 +109,10 @@ grpc_auth_json_key grpc_auth_json_key_create_from_string(
 
   prop_value = json_get_string_property(json, "type");
   if (prop_value == NULL ||
-      strcmp(prop_value, GRPC_AUTH_JSON_KEY_TYPE_SERVICE_ACCOUNT)) {
+      strcmp(prop_value, GRPC_AUTH_JSON_TYPE_SERVICE_ACCOUNT)) {
     goto end;
   }
-  result.type = GRPC_AUTH_JSON_KEY_TYPE_SERVICE_ACCOUNT;
+  result.type = GRPC_AUTH_JSON_TYPE_SERVICE_ACCOUNT;
 
   if (!set_json_key_string_property(json, "private_key_id",
                                     &result.private_key_id) ||
@@ -148,7 +149,7 @@ end:
 
 void grpc_auth_json_key_destruct(grpc_auth_json_key *json_key) {
   if (json_key == NULL) return;
-  json_key->type = GRPC_AUTH_JSON_KEY_TYPE_INVALID;
+  json_key->type = GRPC_AUTH_JSON_TYPE_INVALID;
   if (json_key->client_id != NULL) {
     gpr_free(json_key->client_id);
     json_key->client_id = NULL;
@@ -331,3 +332,67 @@ void grpc_jwt_encode_and_sign_set_override(
     grpc_jwt_encode_and_sign_override func) {
   g_jwt_encode_and_sign_override = func;
 }
+
+/* --- grpc_auth_refresh_token --- */
+
+int grpc_auth_refresh_token_is_valid(
+    const grpc_auth_refresh_token *refresh_token) {
+  return (refresh_token != NULL) &&
+         strcmp(refresh_token->type, GRPC_AUTH_JSON_TYPE_INVALID);
+}
+
+grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
+    const char *json_string) {
+  grpc_auth_refresh_token result;
+  char *scratchpad = gpr_strdup(json_string);
+  grpc_json *json = grpc_json_parse_string(scratchpad);
+  const char *prop_value;
+  int success = 0;
+
+  memset(&result, 0, sizeof(grpc_auth_refresh_token));
+  result.type = GRPC_AUTH_JSON_TYPE_INVALID;
+  if (json == NULL) {
+    gpr_log(GPR_ERROR, "Invalid json string %s", json_string);
+    goto end;
+  }
+
+  prop_value = json_get_string_property(json, "type");
+  if (prop_value == NULL ||
+      strcmp(prop_value, GRPC_AUTH_JSON_TYPE_AUTHORIZED_USER)) {
+    goto end;
+  }
+  result.type = GRPC_AUTH_JSON_TYPE_AUTHORIZED_USER;
+
+  if (!set_json_key_string_property(json, "client_secret",
+                                    &result.client_secret) ||
+      !set_json_key_string_property(json, "client_id", &result.client_id) ||
+      !set_json_key_string_property(json, "refresh_token",
+                                    &result.refresh_token)) {
+    goto end;
+  }
+  success = 1;
+
+end:
+  if (json != NULL) grpc_json_destroy(json);
+  if (!success) grpc_auth_refresh_token_destruct(&result);
+  gpr_free(scratchpad);
+  return result;
+}
+
+void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token *refresh_token) {
+  if (refresh_token == NULL) return;
+  refresh_token->type = GRPC_AUTH_JSON_TYPE_INVALID;
+  if (refresh_token->client_id != NULL) {
+    gpr_free(refresh_token->client_id);
+    refresh_token->client_id = NULL;
+  }
+  if (refresh_token->client_secret != NULL) {
+    gpr_free(refresh_token->client_secret);
+    refresh_token->client_secret = NULL;
+  }
+  if (refresh_token->refresh_token != NULL) {
+    gpr_free(refresh_token->refresh_token);
+    refresh_token->refresh_token = NULL;
+  }
+}
+

src/core/security/json_token.h

@@ -44,7 +44,7 @@
 /* --- auth_json_key parsing. --- */
 
 typedef struct {
-  char *type;
+  const char *type;
   char *private_key_id;
   char *client_id;
   char *client_email;
@@ -79,4 +79,25 @@ typedef char *(*grpc_jwt_encode_and_sign_override)(
 void grpc_jwt_encode_and_sign_set_override(
     grpc_jwt_encode_and_sign_override func);
 
+/* --- auth_refresh_token parsing. --- */
+
+typedef struct {
+  const char *type;
+  char *client_id;
+  char *client_secret;
+  char *refresh_token;
+} grpc_auth_refresh_token;
+
+/* Returns 1 if the object is valid, 0 otherwise. */
+int grpc_auth_refresh_token_is_valid(
+    const grpc_auth_refresh_token *refresh_token);
+
+/* Creates a refresh token object from string. Returns an invalid object if a
+   parsing error has been encountered. */
+grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
+    const char *json_string);
+
+/* Destructs the object. */
+void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token *refresh_token);
+
 #endif  /* GRPC_INTERNAL_CORE_SECURITY_JSON_TOKEN_H */

src/core/transport/chttp2_transport.c

@@ -1655,7 +1655,15 @@ static int process_read(transport *t, gpr_slice slice) {
       if (!init_frame_parser(t)) {
         return 0;
       }
-      t->last_incoming_stream_id = t->incoming_stream_id;
+      /* t->last_incoming_stream_id is used as last-stream-id when
+         sending GOAWAY frame.
+         https://tools.ietf.org/html/draft-ietf-httpbis-http2-17#section-6.8
+         says that last-stream-id is peer-initiated stream ID.  So,
+         since we don't have server pushed streams, client should send
+         GOAWAY last-stream-id=0 in this case. */
+      if (!t->is_client) {
+        t->last_incoming_stream_id = t->incoming_stream_id;
+      }
       if (t->incoming_frame_size == 0) {
         if (!parse_frame_slice(t, gpr_empty_slice(), 1)) {
           return 0;

src/cpp/client/insecure_credentials.cc

@@ -54,7 +54,7 @@ class InsecureCredentialsImpl GRPC_FINAL : public Credentials {
         target, grpc_channel_create(target.c_str(), &channel_args)));
   }
 
-  SecureCredentials* AsSecureCredentials() { return nullptr; }
+  SecureCredentials* AsSecureCredentials() GRPC_OVERRIDE { return nullptr; }
 };
 }  // namespace
 

src/cpp/client/secure_credentials.cc

@@ -59,7 +59,7 @@ class SecureCredentials GRPC_FINAL : public Credentials {
         grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args)));
   }
 
-  SecureCredentials* AsSecureCredentials() { return this; }
+  SecureCredentials* AsSecureCredentials() GRPC_OVERRIDE { return this; }
 
  private:
   grpc_credentials* const c_creds_;
@@ -98,12 +98,30 @@ std::unique_ptr<Credentials> ComputeEngineCredentials() {
 std::unique_ptr<Credentials> ServiceAccountCredentials(
     const grpc::string& json_key, const grpc::string& scope,
     std::chrono::seconds token_lifetime) {
-  gpr_timespec lifetime = gpr_time_from_seconds(
-      token_lifetime.count() > 0 ? token_lifetime.count() : 0);
+  if (token_lifetime.count() <= 0) {
+    gpr_log(GPR_ERROR,
+            "Trying to create ServiceAccountCredentials "
+            "with non-positive lifetime");
+    return WrapCredentials(nullptr);
+  }
+  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime.count());
   return WrapCredentials(grpc_service_account_credentials_create(
       json_key.c_str(), scope.c_str(), lifetime));
 }
 
+// Builds JWT credentials.
+std::unique_ptr<Credentials> JWTCredentials(
+    const grpc::string &json_key, std::chrono::seconds token_lifetime) {
+  if (token_lifetime.count() <= 0) {
+    gpr_log(GPR_ERROR,
+            "Trying to create JWTCredentials with non-positive lifetime");
+    return WrapCredentials(nullptr);
+  }
+  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime.count());
+  return WrapCredentials(
+      grpc_jwt_credentials_create(json_key.c_str(), lifetime));
+}
+
 // Builds IAM credentials.
 std::unique_ptr<Credentials> IAMCredentials(
     const grpc::string& authorization_token,

src/cpp/proto/proto_utils.cc

@@ -39,12 +39,11 @@
 #include <grpc/support/slice.h>
 #include <grpc/support/slice_buffer.h>
 #include <grpc/support/port_platform.h>
-#include <google/protobuf/io/zero_copy_stream.h>
 
 const int kMaxBufferLength = 8192;
 
 class GrpcBufferWriter GRPC_FINAL
-    : public ::google::protobuf::io::ZeroCopyOutputStream {
+    : public ::grpc::protobuf::io::ZeroCopyOutputStream {
  public:
   explicit GrpcBufferWriter(grpc_byte_buffer **bp,
                             int block_size = kMaxBufferLength)
@@ -85,7 +84,7 @@ class GrpcBufferWriter GRPC_FINAL
     byte_count_ -= count;
   }
 
-  gpr_int64 ByteCount() const GRPC_OVERRIDE { return byte_count_; }
+  grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE { return byte_count_; }
 
  private:
   const int block_size_;
@@ -97,7 +96,7 @@ class GrpcBufferWriter GRPC_FINAL
 };
 
 class GrpcBufferReader GRPC_FINAL
-    : public ::google::protobuf::io::ZeroCopyInputStream {
+    : public ::grpc::protobuf::io::ZeroCopyInputStream {
  public:
   explicit GrpcBufferReader(grpc_byte_buffer *buffer)
       : byte_count_(0), backup_count_(0) {
@@ -143,7 +142,7 @@ class GrpcBufferReader GRPC_FINAL
     return false;
   }
 
-  gpr_int64 ByteCount() const GRPC_OVERRIDE {
+  grpc::protobuf::int64 ByteCount() const GRPC_OVERRIDE {
     return byte_count_ - backup_count_;
   }
 

src/cpp/server/server.cc

@@ -181,12 +181,12 @@ Server::Server(ThreadPoolInterface* thread_pool, bool thread_pool_owned)
       thread_pool_owned_(thread_pool_owned) {}
 
 Server::~Server() {
-  std::unique_lock<std::mutex> lock(mu_);
-  if (started_ && !shutdown_) {
-    lock.unlock();
-    Shutdown();
-  } else {
-    lock.unlock();
+  {
+    std::unique_lock<std::mutex> lock(mu_);
+    if (started_ && !shutdown_) {
+      lock.unlock();
+      Shutdown();
+    }
   }
   grpc_server_destroy(server_);
   if (thread_pool_owned_) {

src/csharp/Grpc.Core.Tests/ClientServerTest.cs

@@ -122,10 +122,13 @@ namespace Grpc.Core.Tests
             {
                 var call = new Call<string, string>(unaryEchoStringMethod, channel);
 
-                try {
+                try
+                {
                     Calls.BlockingUnaryCall(call, "ABC", default(CancellationToken));
                     Assert.Fail();
-                } catch(RpcException e) {
+                }
+                catch (RpcException e)
+                {
                     Assert.AreEqual(StatusCode.Unimplemented, e.Status.StatusCode);
                 }
             }
@@ -140,4 +143,3 @@ namespace Grpc.Core.Tests
         }
     }
 }
-

src/csharp/Grpc.Core.Tests/GrpcEnvironmentTest.cs

@@ -68,7 +68,7 @@ namespace Grpc.Core.Tests
             var tp2 = GrpcEnvironment.ThreadPool;
             GrpcEnvironment.Shutdown();
 
-            Assert.IsFalse(Object.ReferenceEquals(tp1, tp2));
+            Assert.IsFalse(object.ReferenceEquals(tp1, tp2));
         }
     }
 }

src/csharp/Grpc.Core.Tests/PInvokeTest.cs

@@ -33,13 +33,13 @@
 
 using System;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Grpc.Core;
 using Grpc.Core.Internal;
 using Grpc.Core.Utils;
 using NUnit.Framework;
-using System.Runtime.InteropServices;
 
 namespace Grpc.Core.Tests
 {
@@ -73,14 +73,13 @@ namespace Grpc.Core.Tests
         {
             BenchmarkUtil.RunBenchmark(
                 100000, 1000000,
-                () => {
+                () =>
+                {
                     CompletionQueueSafeHandle cq = CompletionQueueSafeHandle.Create();
                     cq.Dispose();
-                }
-            );
+                });
         }
 
-
         /// <summary>
         /// Approximate results:
         /// (~80ns Mono Linux)
@@ -94,10 +93,10 @@ namespace Grpc.Core.Tests
             counter = 0;
             BenchmarkUtil.RunBenchmark(
                 1000000, 10000000,
-                () => {
+                () =>
+                {
                     grpcsharp_test_callback(handler);
-                }
-            );
+                });
             Assert.AreNotEqual(0, counter);
         }
 
@@ -113,10 +112,10 @@ namespace Grpc.Core.Tests
             counter = 0;
             BenchmarkUtil.RunBenchmark(
                 10000, 10000,
-                () => {
-                grpcsharp_test_callback(new CompletionCallbackDelegate(Handler));
-            }
-            );
+                () =>
+                {
+                    grpcsharp_test_callback(new CompletionCallbackDelegate(Handler));
+                });
             Assert.AreNotEqual(0, counter);
         }
 
@@ -129,15 +128,15 @@ namespace Grpc.Core.Tests
         {
             BenchmarkUtil.RunBenchmark(
                 1000000, 100000000,
-                () => {
+                () =>
+                {
                     grpcsharp_test_nop(IntPtr.Zero);
-                }
-            );
+                });
         }
 
-        private void Handler(GRPCOpError op, IntPtr ptr) {
-            counter ++;
+        private void Handler(GRPCOpError op, IntPtr ptr)
+        {
+            counter++;
         }
     }
 }
-

src/csharp/Grpc.Core.Tests/Properties/AssemblyInfo.cs

@@ -1,8 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
 [assembly: AssemblyTitle("Grpc.Core.Tests")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -11,12 +9,4 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
 [assembly: AssemblyVersion("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-

src/csharp/Grpc.Core.Tests/ServerTest.cs

@@ -53,6 +53,5 @@ namespace Grpc.Core.Tests
 
             GrpcEnvironment.Shutdown();
         }
-
     }
 }

src/csharp/Grpc.Core.Tests/TimespecTest.cs

@@ -86,4 +86,3 @@ namespace Grpc.Core.Internal.Tests
         }
     }
 }
-

src/csharp/Grpc.Core/Call.cs

@@ -47,7 +47,8 @@ namespace Grpc.Core
                     Func<TRequest, byte[]> requestSerializer,
                     Func<byte[], TResponse> responseDeserializer,
                     TimeSpan timeout,
-                    Channel channel) {
+                    Channel channel)
+        {
             this.methodName = methodName;
             this.requestSerializer = requestSerializer;
             this.responseDeserializer = responseDeserializer;
@@ -95,4 +96,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Calls.cs

@@ -38,8 +38,6 @@ using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
-    // NOTE: this class is work-in-progress
-
     /// <summary>
     /// Helper methods for generated stubs to make RPC calls.
     /// </summary>
@@ -89,9 +87,9 @@ namespace Grpc.Core
             return new ClientStreamingInputObserver<TRequest, TResponse>(asyncCall);
         }
 
-        private static CompletionQueueSafeHandle GetCompletionQueue() {
+        private static CompletionQueueSafeHandle GetCompletionQueue()
+        {
             return GrpcEnvironment.ThreadPool.CompletionQueue;
         }
     }
 }
-

src/csharp/Grpc.Core/Channel.cs

@@ -36,10 +36,13 @@ using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
+    /// <summary>
+    /// gRPC Channel
+    /// </summary>
     public class Channel : IDisposable
     {
         readonly ChannelSafeHandle handle;
-        readonly String target;
+        readonly string target;
 
         /// <summary>
         /// Creates a channel.

src/csharp/Grpc.Core/ChannelArgs.cs

@@ -30,6 +30,7 @@
 #endregion
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -37,33 +38,18 @@ using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
-    // TODO: should we be using the builder pattern?
+    /// <summary>
+    /// gRPC channel options.
+    /// </summary>
     public class ChannelArgs
     {
         public const string SslTargetNameOverrideKey = "grpc.ssl_target_name_override";
 
-        public class Builder
-        {
-            Dictionary<string,string> stringArgs = new Dictionary<string,string>();
-            // TODO: AddInteger not supported yet.
-            public Builder AddString(string key, string value)
-            {
-                stringArgs.Add(key, value);
-                return this;
-            }
+        readonly ImmutableDictionary<string, string> stringArgs;
 
-            public ChannelArgs Build()
-            {
-                return new ChannelArgs(stringArgs);
-            }
-        }
-
-        Dictionary<string,string> stringArgs;
-
-        private ChannelArgs(Dictionary<string, string> stringArgs)
+        private ChannelArgs(ImmutableDictionary<string, string> stringArgs)
         {
-            // TODO: use immutable dict?
-            this.stringArgs = new Dictionary<string, string>(stringArgs);
+            this.stringArgs = stringArgs;
         }
 
         public string GetSslTargetNameOverride()
@@ -76,11 +62,28 @@ namespace Grpc.Core
             return null;
         }
 
-        public static Builder NewBuilder()
+        public static Builder CreateBuilder()
         {
             return new Builder();
         }
 
+        public class Builder
+        {
+            readonly Dictionary<string, string> stringArgs = new Dictionary<string, string>();
+
+            // TODO: AddInteger not supported yet.
+            public Builder AddString(string key, string value)
+            {
+                stringArgs.Add(key, value);
+                return this;
+            }
+
+            public ChannelArgs Build()
+            {
+                return new ChannelArgs(stringArgs.ToImmutableDictionary());
+            }
+        }
+
         /// <summary>
         /// Creates native object for the channel arguments.
         /// </summary>

src/csharp/Grpc.Core/ClientStreamingAsyncResult.cs

@@ -67,4 +67,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Credentials.cs

@@ -36,6 +36,9 @@ using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
+    /// <summary>
+    /// Client-side credentials.
+    /// </summary>
     public abstract class Credentials
     {
         /// <summary>
@@ -74,4 +77,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Grpc.Core.csproj

@@ -31,6 +31,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Collections.Immutable">
+      <HintPath>..\packages\System.Collections.Immutable.1.1.34-rc\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Internal\GrpcLog.cs" />
@@ -54,7 +57,7 @@
     <Compile Include="Internal\ServerSafeHandle.cs" />
     <Compile Include="Method.cs" />
     <Compile Include="ServerCalls.cs" />
-    <Compile Include="ServerCallHandler.cs" />
+    <Compile Include="Internal\ServerCallHandler.cs" />
     <Compile Include="Marshaller.cs" />
     <Compile Include="ServerServiceDefinition.cs" />
     <Compile Include="Utils\RecordingObserver.cs" />
@@ -77,6 +80,9 @@
     <Compile Include="Internal\ServerCredentialsSafeHandle.cs" />
     <Compile Include="ServerCredentials.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Choose>
     <!-- Under older versions of Monodevelop, Choose is not supported and is just
          ignored, which gives us the desired effect. -->

src/csharp/Grpc.Core/GrpcEnvironment.cs

@@ -63,8 +63,9 @@ namespace Grpc.Core
         /// lifetime (and call Shutdown once you're done), for the sake of easier testing it's
         /// allowed to initialize the environment again after it has been successfully shutdown.
         /// </summary>
-        public static void Initialize() {
-            lock(staticLock)
+        public static void Initialize()
+        {
+            lock (staticLock)
             {
                 if (instance == null)
                 {
@@ -79,7 +80,7 @@ namespace Grpc.Core
         /// </summary>
         public static void Shutdown()
         {
-            lock(staticLock)
+            lock (staticLock)
             {
                 if (instance != null)
                 {
@@ -133,4 +134,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Internal/AsyncCall.cs

@@ -54,7 +54,7 @@ namespace Grpc.Core.Internal
         TaskCompletionSource<TResponse> unaryResponseTcs;
 
         // Set after status is received. Only used for streaming response calls.
-        Nullable<Status> finishedStatus;
+        Status? finishedStatus;
 
         bool readObserverCompleted;  // True if readObserver has already been completed.
 
@@ -64,7 +64,7 @@ namespace Grpc.Core.Internal
             this.finishedHandler = CreateBatchCompletionCallback(HandleFinished);
         }
 
-        public void Initialize(Channel channel, CompletionQueueSafeHandle cq, String methodName)
+        public void Initialize(Channel channel, CompletionQueueSafeHandle cq, string methodName)
         {
             var call = CallSafeHandle.Create(channel.Handle, cq, methodName, channel.Target, Timespec.InfFuture);
             InitializeInternal(call);
@@ -77,9 +77,9 @@ namespace Grpc.Core.Internal
         /// <summary>
         /// Blocking unary request - unary response call.
         /// </summary>
-        public TResponse UnaryCall(Channel channel, String methodName, TRequest msg)
+        public TResponse UnaryCall(Channel channel, string methodName, TRequest msg)
         {
-            using(CompletionQueueSafeHandle cq = CompletionQueueSafeHandle.Create())
+            using (CompletionQueueSafeHandle cq = CompletionQueueSafeHandle.Create())
             {
                 byte[] payload = UnsafeSerialize(msg);
 
@@ -254,7 +254,7 @@ namespace Grpc.Core.Internal
         /// </summary>
         private void HandleUnaryResponse(bool wasError, BatchContextSafeHandleNotOwned ctx)
         {
-            lock(myLock)
+            lock (myLock)
             {
                 finished = true;
                 halfclosed = true;
@@ -264,9 +264,7 @@ namespace Grpc.Core.Internal
 
             if (wasError)
             {
-                unaryResponseTcs.SetException(new RpcException(
-                    new Status(StatusCode.Internal, "Internal error occured.")
-                ));
+                unaryResponseTcs.SetException(new RpcException(new Status(StatusCode.Internal, "Internal error occured.")));
                 return;
             }
 

src/csharp/Grpc.Core/Internal/AsyncCallBase.cs

@@ -225,7 +225,7 @@ namespace Grpc.Core.Internal
                 payload = serializer(msg);
                 return true;
             }
-            catch(Exception)
+            catch (Exception)
             {
                 Console.WriteLine("Exception occured while trying to serialize message");
                 payload = null;
@@ -240,7 +240,7 @@ namespace Grpc.Core.Internal
                 msg = deserializer(payload);
                 return true;
             } 
-            catch(Exception)
+            catch (Exception)
             {
                 Console.WriteLine("Exception occured while trying to deserialize message");
                 msg = default(TRead);
@@ -254,7 +254,7 @@ namespace Grpc.Core.Internal
             {
                 readObserver.OnNext(value);
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 Console.WriteLine("Exception occured while invoking readObserver.OnNext: " + e);
             }
@@ -266,7 +266,7 @@ namespace Grpc.Core.Internal
             {
                 readObserver.OnCompleted();
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 Console.WriteLine("Exception occured while invoking readObserver.OnCompleted: " + e);
             }
@@ -278,7 +278,7 @@ namespace Grpc.Core.Internal
             {
                 readObserver.OnError(error);
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 Console.WriteLine("Exception occured while invoking readObserver.OnError: " + e);
             }
@@ -290,7 +290,7 @@ namespace Grpc.Core.Internal
             {
                 completionDelegate(error);
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 Console.WriteLine("Exception occured while invoking completion delegate: " + e);
             }
@@ -302,14 +302,15 @@ namespace Grpc.Core.Internal
         /// </summary>
         protected CompletionCallbackDelegate CreateBatchCompletionCallback(Action<bool, BatchContextSafeHandleNotOwned> handler)
         {
-            return new CompletionCallbackDelegate( (error, batchContextPtr) => {
+            return new CompletionCallbackDelegate((error, batchContextPtr) =>
+            {
                 try
                 {
                     var ctx = new BatchContextSafeHandleNotOwned(batchContextPtr);
                     bool wasError = (error != GRPCOpError.GRPC_OP_OK);
                     handler(wasError, ctx);
                 }
-                catch(Exception e)
+                catch (Exception e)
                 {
                     Console.WriteLine("Caught exception in a native handler: " + e);
                 }
@@ -363,7 +364,6 @@ namespace Grpc.Core.Internal
             {
                 FireCompletion(origCompletionDelegate, null);
             }
-           
         }
 
         /// <summary>

src/csharp/Grpc.Core/Internal/AsyncCompletion.cs

@@ -91,5 +91,4 @@ namespace Grpc.Core.Internal
             tcs.SetException(error);
         }
     }
-
 }

src/csharp/Grpc.Core/Internal/BatchContextSafeHandleNotOwned.cs

@@ -80,16 +80,18 @@ namespace Grpc.Core.Internal
             {
                 return null;
             }
-            byte[] data = new byte[(int) len];
+            byte[] data = new byte[(int)len];
             grpcsharp_batch_context_recv_message_to_buffer(this, data, new UIntPtr((ulong)data.Length));
             return data;
         }
 
-        public CallSafeHandle GetServerRpcNewCall() {
+        public CallSafeHandle GetServerRpcNewCall()
+        {
             return grpcsharp_batch_context_server_rpc_new_call(this);
         }
 
-        public string GetServerRpcNewMethod() {
+        public string GetServerRpcNewMethod()
+        {
             return Marshal.PtrToStringAnsi(grpcsharp_batch_context_server_rpc_new_method(this));
         }
     }

src/csharp/Grpc.Core/Internal/CallSafeHandle.cs

@@ -36,13 +36,14 @@ using Grpc.Core;
 
 namespace Grpc.Core.Internal
 {
-    internal delegate void CompletionCallbackDelegate(GRPCOpError error,IntPtr batchContextPtr);
+    internal delegate void CompletionCallbackDelegate(GRPCOpError error, IntPtr batchContextPtr);
+    
     /// <summary>
     /// grpc_call from <grpc/grpc.h>
     /// </summary>
     internal class CallSafeHandle : SafeHandleZeroIsInvalid
     {
-        const UInt32 GRPC_WRITE_BUFFER_HINT = 1;
+        const uint GRPC_WRITE_BUFFER_HINT = 1;
 
         [DllImport("grpc_csharp_ext.dll")]
         static extern CallSafeHandle grpcsharp_channel_create_call(ChannelSafeHandle channel, CompletionQueueSafeHandle cq, string method, string host, Timespec deadline);
@@ -179,7 +180,7 @@ namespace Grpc.Core.Internal
             Trace.Assert(callError == GRPCCallError.GRPC_CALL_OK, "Status not GRPC_CALL_OK");
         }
 
-        private static UInt32 GetFlags(bool buffered)
+        private static uint GetFlags(bool buffered)
         {
             return buffered ? 0 : GRPC_WRITE_BUFFER_HINT;
         }

src/csharp/Grpc.Core/Internal/ChannelArgsSafeHandle.cs

@@ -74,4 +74,3 @@ namespace Grpc.Core.Internal
         }
     }
 }
-

src/csharp/Grpc.Core/Internal/CompletionQueueSafeHandle.cs

@@ -77,4 +77,3 @@ namespace Grpc.Core.Internal
         }
     }
 }
-

src/csharp/Grpc.Core/Internal/Enums.cs

@@ -112,4 +112,3 @@ namespace Grpc.Core.Internal
         GRPC_OP_ERROR
     }
 }
-

src/csharp/Grpc.Core/Internal/GrpcLog.cs

@@ -40,7 +40,7 @@ using System.Threading;
 
 namespace Grpc.Core.Internal
 {
-    internal delegate void GprLogDelegate(IntPtr fileStringPtr, Int32 line, UInt64 threadId, IntPtr severityStringPtr, IntPtr msgPtr);
+    internal delegate void GprLogDelegate(IntPtr fileStringPtr, int line, ulong threadId, IntPtr severityStringPtr, IntPtr msgPtr);
 
     /// <summary>
     /// Logs from gRPC C core library can get lost if your application is not a console app.
@@ -73,7 +73,7 @@ namespace Grpc.Core.Internal
             }
         }
 
-        private static void HandleWrite(IntPtr fileStringPtr, Int32 line, UInt64 threadId, IntPtr severityStringPtr, IntPtr msgPtr)
+        private static void HandleWrite(IntPtr fileStringPtr, int line, ulong threadId, IntPtr severityStringPtr, IntPtr msgPtr)
         {
             try
             {

src/csharp/Grpc.Core/Internal/GrpcThreadPool.cs

@@ -51,12 +51,13 @@ namespace Grpc.Core.Internal
 
         CompletionQueueSafeHandle cq;
 
-        public GrpcThreadPool(int poolSize) {
+        public GrpcThreadPool(int poolSize)
+        {
             this.poolSize = poolSize;
         }
 
-        public void Start() {
-
+        public void Start()
+        {
             lock (myLock)
             {
                 if (cq != null)
@@ -73,8 +74,8 @@ namespace Grpc.Core.Internal
             }
         }
 
-        public void Stop() {
-
+        public void Stop()
+        {
             lock (myLock)
             {
                 cq.Shutdown();
@@ -86,7 +87,6 @@ namespace Grpc.Core.Internal
                 }
 
                 cq.Dispose();
-
             }
         }
 
@@ -116,10 +116,9 @@ namespace Grpc.Core.Internal
             do
             {
                 completionType = cq.NextWithCallback();
-            } while(completionType != GRPCCompletionType.GRPC_QUEUE_SHUTDOWN);
+            }
+            while (completionType != GRPCCompletionType.GRPC_QUEUE_SHUTDOWN);
             Console.WriteLine("Completion queue has shutdown successfully, thread " + Thread.CurrentThread.Name + " exiting.");
         }
     }
-
 }
-

src/csharp/Grpc.Core/Internal/SafeHandleZeroIsInvalid.cs

@@ -64,4 +64,3 @@ namespace Grpc.Core.Internal
         }
     }
 }
-

src/csharp/Grpc.Core/ServerCallHandler.cs → src/csharp/Grpc.Core/Internal/ServerCallHandler.cs

@@ -36,7 +36,7 @@ using System.Linq;
 using Grpc.Core.Internal;
 using Grpc.Core.Utils;
 
-namespace Grpc.Core
+namespace Grpc.Core.Internal
 {
     internal interface IServerCallHandler
     {
@@ -70,7 +70,6 @@ namespace Grpc.Core
             handler(request, responseObserver);
 
             finishedTask.Wait();
-
         }
     }
 
@@ -93,7 +92,7 @@ namespace Grpc.Core
 
             asyncCall.Initialize(call);
 
-            var responseObserver = new ServerStreamingOutputObserver<TRequest,TResponse>(asyncCall);
+            var responseObserver = new ServerStreamingOutputObserver<TRequest, TResponse>(asyncCall);
             var requestObserver = handler(responseObserver);
             var finishedTask = asyncCall.ServerSideCallAsync(requestObserver);
             finishedTask.Wait();
@@ -113,7 +112,7 @@ namespace Grpc.Core
             var finishedTask = asyncCall.ServerSideCallAsync(new NullObserver<byte[]>());
 
             // TODO: check result of the completion status.
-            asyncCall.StartSendStatusFromServer(new Status(StatusCode.Unimplemented, "No such method."), new AsyncCompletionDelegate((error) => {}));
+            asyncCall.StartSendStatusFromServer(new Status(StatusCode.Unimplemented, "No such method."), new AsyncCompletionDelegate((error) => { }));
 
             finishedTask.Wait();
         }
@@ -132,7 +131,5 @@ namespace Grpc.Core
         public void OnNext(T value)
         {
         }
-
     }
 }
-

src/csharp/Grpc.Core/Internal/ServerSafeHandle.cs

@@ -53,10 +53,10 @@ namespace Grpc.Core.Internal
         static extern ServerSafeHandle grpcsharp_server_create(CompletionQueueSafeHandle cq, IntPtr args);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern Int32 grpcsharp_server_add_http2_port(ServerSafeHandle server, string addr);
+        static extern int grpcsharp_server_add_http2_port(ServerSafeHandle server, string addr);
 
         [DllImport("grpc_csharp_ext.dll")]
-        static extern Int32 grpcsharp_server_add_secure_http2_port(ServerSafeHandle server, string addr, ServerCredentialsSafeHandle creds);
+        static extern int grpcsharp_server_add_secure_http2_port(ServerSafeHandle server, string addr, ServerCredentialsSafeHandle creds);
 
         [DllImport("grpc_csharp_ext.dll")]
         static extern void grpcsharp_server_start(ServerSafeHandle server);

src/csharp/Grpc.Core/Internal/ServerStreamingOutputObserver.cs

@@ -69,4 +69,3 @@ namespace Grpc.Core.Internal
         }
     }
 }
-

src/csharp/Grpc.Core/Internal/Timespec.cs

@@ -40,8 +40,8 @@ namespace Grpc.Core.Internal
     [StructLayout(LayoutKind.Sequential)]
     internal struct Timespec
     {
-        const int nanosPerSecond = 1000 * 1000 * 1000;
-        const int nanosPerTick = 100;
+        const int NanosPerSecond = 1000 * 1000 * 1000;
+        const int NanosPerTick = 100;
 
         [DllImport("grpc_csharp_ext.dll")]
         static extern Timespec gprsharp_now();
@@ -99,14 +99,13 @@ namespace Grpc.Core.Internal
 
         public Timespec Add(TimeSpan timeSpan)
         {
-            long nanos = tv_nsec.ToInt64() + (timeSpan.Ticks % TimeSpan.TicksPerSecond) * nanosPerTick;
-            long overflow_sec = (nanos > nanosPerSecond) ? 1 : 0;
+            long nanos = tv_nsec.ToInt64() + (timeSpan.Ticks % TimeSpan.TicksPerSecond) * NanosPerTick;
+            long overflow_sec = (nanos > NanosPerSecond) ? 1 : 0;
 
             Timespec result;
-            result.tv_nsec = new IntPtr(nanos % nanosPerSecond);
+            result.tv_nsec = new IntPtr(nanos % NanosPerSecond);
             result.tv_sec = new IntPtr(tv_sec.ToInt64() + (timeSpan.Ticks / TimeSpan.TicksPerSecond) + overflow_sec);
             return result;
         }
     }
 }
-

src/csharp/Grpc.Core/Marshaller.cs

@@ -40,8 +40,8 @@ namespace Grpc.Core
     /// </summary>
     public struct Marshaller<T>
     {
-        readonly Func<T,byte[]> serializer;
-        readonly Func<byte[],T> deserializer;
+        readonly Func<T, byte[]> serializer;
+        readonly Func<byte[], T> deserializer;
 
         public Marshaller(Func<T, byte[]> serializer, Func<byte[], T> deserializer)
         {
@@ -66,9 +66,12 @@ namespace Grpc.Core
         }
     }
 
-    public static class Marshallers {
-
-        public static Marshaller<T> Create<T>(Func<T,byte[]> serializer, Func<byte[],T> deserializer)
+    /// <summary>
+    /// Utilities for creating marshallers.
+    /// </summary>
+    public static class Marshallers
+    {
+        public static Marshaller<T> Create<T>(Func<T, byte[]> serializer, Func<byte[], T> deserializer)
         {
             return new Marshaller<T>(serializer, deserializer);
         }
@@ -81,7 +84,5 @@ namespace Grpc.Core
                                               System.Text.Encoding.UTF8.GetString);
             }
         }
-
     }
 }
-

src/csharp/Grpc.Core/Method.cs

@@ -94,4 +94,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/OperationFailedException.cs

@@ -45,4 +45,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Properties/AssemblyInfo.cs

@@ -1,24 +1,14 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
-[assembly: AssemblyTitle ("Grpc.Core")]
-[assembly: AssemblyDescription ("")]
-[assembly: AssemblyConfiguration ("")]
-[assembly: AssemblyCompany ("")]
-[assembly: AssemblyProduct ("")]
-[assembly: AssemblyCopyright ("Google Inc.  All rights reserved.")]
-[assembly: AssemblyTrademark ("")]
-[assembly: AssemblyCulture ("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
-[assembly: AssemblyVersion ("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
+[assembly: AssemblyTitle("Grpc.Core")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyVersion("0.1.*")]
 
 [assembly: InternalsVisibleTo("Grpc.Core.Tests")]
-

src/csharp/Grpc.Core/RpcException.cs

@@ -35,6 +35,9 @@ using System;
 
 namespace Grpc.Core
 {
+    /// <summary>
+    /// Thrown when remote procedure call fails.
+    /// </summary>
     public class RpcException : Exception
     {
         private readonly Status status;
@@ -58,4 +61,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/Server.cs

@@ -67,8 +67,9 @@ namespace Grpc.Core
         }
 
         // only call this before Start()
-        public void AddServiceDefinition(ServerServiceDefinition serviceDefinition) {
-            foreach(var entry in serviceDefinition.CallHandlers)
+        public void AddServiceDefinition(ServerServiceDefinition serviceDefinition)
+        {
+            foreach (var entry in serviceDefinition.CallHandlers)
             {
                 callHandlers.Add(entry.Key, entry.Value);
             }
@@ -108,7 +109,7 @@ namespace Grpc.Core
             {
                 var rpcInfo = newRpcQueue.Take();
 
-                //Console.WriteLine("Server received RPC " + rpcInfo.Method);
+                // Console.WriteLine("Server received RPC " + rpcInfo.Method);
 
                 IServerCallHandler callHandler;
                 if (!callHandlers.TryGetValue(rpcInfo.Method, out callHandler))
@@ -117,7 +118,7 @@ namespace Grpc.Core
                 }
                 callHandler.StartCall(rpcInfo.Method, rpcInfo.Call, GetCompletionQueue());
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 Console.WriteLine("Exception while handling RPC: " + e);
             }
@@ -128,7 +129,8 @@ namespace Grpc.Core
         /// cleans up used resources.
         /// </summary>
         /// <returns>The async.</returns>
-        public async Task ShutdownAsync() {
+        public async Task ShutdownAsync()
+        {
             handle.ShutdownAndNotify(serverShutdownHandler);
             await shutdownTcs.Task;
             handle.Dispose();
@@ -145,11 +147,13 @@ namespace Grpc.Core
             }
         }
 
-        public void Kill() {
+        public void Kill()
+        {
             handle.Dispose();
         }
 
-        private async Task StartHandlingRpcs() {
+        private async Task StartHandlingRpcs()
+        {
             while (true)
             {
                 await Task.Factory.StartNew(RunRpc);
@@ -161,22 +165,27 @@ namespace Grpc.Core
             AssertCallOk(handle.RequestCall(GetCompletionQueue(), newServerRpcHandler));
         }
 
-        private void HandleNewServerRpc(GRPCOpError error, IntPtr batchContextPtr) {
-            try {
+        private void HandleNewServerRpc(GRPCOpError error, IntPtr batchContextPtr)
+        {
+            try
+            {
                 var ctx = new BatchContextSafeHandleNotOwned(batchContextPtr);
 
-                if (error != GRPCOpError.GRPC_OP_OK) {
+                if (error != GRPCOpError.GRPC_OP_OK)
+                {
                     // TODO: handle error
                 }
 
                 var rpcInfo = new NewRpcInfo(ctx.GetServerRpcNewCall(), ctx.GetServerRpcNewMethod());
 
                 // after server shutdown, the callback returns with null call
-                if (!rpcInfo.Call.IsInvalid) {
+                if (!rpcInfo.Call.IsInvalid)
+                {
                     newRpcQueue.Add(rpcInfo);
                 }
-
-            } catch(Exception e) {
+            }
+            catch (Exception e)
+            {
                 Console.WriteLine("Caught exception in a native handler: " + e);
             }
         }

src/csharp/Grpc.Core/ServerCalls.cs

@@ -32,17 +32,18 @@
 #endregion
 
 using System;
+using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
     // TODO: perhaps add also serverSideStreaming and clientSideStreaming
 
-    public delegate void UnaryRequestServerMethod<TRequest, TResponse> (TRequest request, IObserver<TResponse> responseObserver);
+    public delegate void UnaryRequestServerMethod<TRequest, TResponse>(TRequest request, IObserver<TResponse> responseObserver);
 
-    public delegate IObserver<TRequest> StreamingRequestServerMethod<TRequest, TResponse> (IObserver<TResponse> responseObserver);
-
-    internal static class ServerCalls {
+    public delegate IObserver<TRequest> StreamingRequestServerMethod<TRequest, TResponse>(IObserver<TResponse> responseObserver);
 
+    internal static class ServerCalls
+    {
         public static IServerCallHandler UnaryRequestCall<TRequest, TResponse>(Method<TRequest, TResponse> method, UnaryRequestServerMethod<TRequest, TResponse> handler)
         {
             return new UnaryRequestServerCallHandler<TRequest, TResponse>(method, handler);
@@ -52,7 +53,5 @@ namespace Grpc.Core
         {
             return new StreamingRequestServerCallHandler<TRequest, TResponse>(method, handler);
         }
-
     }
 }
-

src/csharp/Grpc.Core/ServerCredentials.cs

@@ -33,10 +33,14 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
+    /// <summary>
+    /// Server side credentials.
+    /// </summary>
     public abstract class ServerCredentials
     {
         /// <summary>
@@ -51,8 +55,8 @@ namespace Grpc.Core
     /// </summary>
     public class KeyCertificatePair
     {
-        string certChain;
-        string privateKey;
+        readonly string certChain;
+        readonly string privateKey;
 
         public KeyCertificatePair(string certChain, string privateKey)
         {
@@ -82,10 +86,9 @@ namespace Grpc.Core
     /// </summary>
     public class SslServerCredentials : ServerCredentials
     {
-        // TODO: immutable list...
-        List<KeyCertificatePair> keyCertPairs;
+        ImmutableList<KeyCertificatePair> keyCertPairs;
 
-        public SslServerCredentials(List<KeyCertificatePair> keyCertPairs)
+        public SslServerCredentials(ImmutableList<KeyCertificatePair> keyCertPairs)
         {
             this.keyCertPairs = keyCertPairs;
         }
@@ -104,4 +107,3 @@ namespace Grpc.Core
         }
     }
 }
-

src/csharp/Grpc.Core/ServerServiceDefinition.cs

@@ -33,22 +33,26 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using Grpc.Core.Internal;
 
 namespace Grpc.Core
 {
+    /// <summary>
+    /// Mapping of method names to server call handlers.
+    /// </summary>
     public class ServerServiceDefinition
     {
         readonly string serviceName;
-        // TODO: we would need an immutable dictionary here...
-        readonly Dictionary<string, IServerCallHandler> callHandlers;
+        readonly ImmutableDictionary<string, IServerCallHandler> callHandlers;
 
-        private ServerServiceDefinition(string serviceName, Dictionary<string, IServerCallHandler> callHandlers)
+        private ServerServiceDefinition(string serviceName, ImmutableDictionary<string, IServerCallHandler> callHandlers)
         {
             this.serviceName = serviceName;
-            this.callHandlers = new Dictionary<string, IServerCallHandler>(callHandlers);
+            this.callHandlers = callHandlers;
         }
 
-        internal Dictionary<string, IServerCallHandler> CallHandlers
+        internal ImmutableDictionary<string, IServerCallHandler> CallHandlers
         {
             get
             {
@@ -56,8 +60,7 @@ namespace Grpc.Core
             }
         }
 
-
-        public static Builder CreateBuilder(String serviceName)
+        public static Builder CreateBuilder(string serviceName)
         {
             return new Builder(serviceName);
         }
@@ -65,7 +68,7 @@ namespace Grpc.Core
         public class Builder
         {
             readonly string serviceName;
-            readonly Dictionary<string, IServerCallHandler> callHandlers = new Dictionary<String, IServerCallHandler>();
+            readonly Dictionary<string, IServerCallHandler> callHandlers = new Dictionary<string, IServerCallHandler>();
 
             public Builder(string serviceName)
             {
@@ -90,9 +93,8 @@ namespace Grpc.Core
 
             public ServerServiceDefinition Build()
             {
-                return new ServerServiceDefinition(serviceName, callHandlers);
+                return new ServerServiceDefinition(serviceName, callHandlers.ToImmutableDictionary());
             }
         }
     }
 }
-

src/csharp/Grpc.Core/StatusCode.cs

@@ -35,9 +35,9 @@ using System;
 
 namespace Grpc.Core
 {
-    // TODO: element names should changed to comply with C# naming conventions.
     /// <summary>
-    /// based on grpc_status_code from grpc/status.h
+    /// Result of a remote procedure call.
+    /// Based on grpc_status_code from grpc/status.h
     /// </summary>
     public enum StatusCode
     {
@@ -139,4 +139,3 @@ namespace Grpc.Core
         DataLoss = 15
     }
 }
-

src/csharp/Grpc.Core/Utils/BenchmarkUtil.cs

@@ -32,10 +32,10 @@
 #endregion
 
 using System;
-using System.Threading.Tasks;
-using System.Collections.Generic;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading.Tasks;
 
 namespace Grpc.Core.Utils
 {
@@ -61,8 +61,7 @@ namespace Grpc.Core.Utils
             }
             stopwatch.Stop();
             Console.WriteLine("Elapsed time: " + stopwatch.ElapsedMilliseconds + "ms");
-            Console.WriteLine("Ops per second: " + (int) ((double) benchmarkIterations  * 1000 / stopwatch.ElapsedMilliseconds));
+            Console.WriteLine("Ops per second: " + (int)((double)benchmarkIterations  * 1000 / stopwatch.ElapsedMilliseconds));
         }
     }
 }
-

src/csharp/Grpc.Core/Utils/ExceptionHelper.cs

@@ -42,7 +42,8 @@ namespace Grpc.Core.Utils
         /// Otherwise, rethrows the original aggregate exception.
         /// Always throws, the exception return type is here only to make the.
         /// </summary>
-        public static Exception UnwrapRpcException(AggregateException ae) {
+        public static Exception UnwrapRpcException(AggregateException ae)
+        {
             foreach (var e in ae.InnerExceptions)
             {
                 if (e is RpcException)
@@ -54,4 +55,3 @@ namespace Grpc.Core.Utils
         }
     }
 }
-

src/csharp/Grpc.Core/Utils/Preconditions.cs

@@ -32,10 +32,10 @@
 #endregion
 
 using System;
-using System.Threading.Tasks;
-using System.Collections.Generic;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading.Tasks;
 
 namespace Grpc.Core.Utils
 {
@@ -66,7 +66,7 @@ namespace Grpc.Core.Utils
         /// <summary>
         /// Throws NullReferenceException if reference is null.
         /// </summary>
-        public static T CheckNotNull<T> (T reference)
+        public static T CheckNotNull<T>(T reference)
         {
             if (reference == null)
             {
@@ -78,7 +78,7 @@ namespace Grpc.Core.Utils
         /// <summary>
         /// Throws NullReferenceException with given message if reference is null.
         /// </summary>
-        public static T CheckNotNull<T> (T reference, string errorMessage)
+        public static T CheckNotNull<T>(T reference, string errorMessage)
         {
             if (reference == null)
             {
@@ -110,4 +110,3 @@ namespace Grpc.Core.Utils
         }
     }
 }
-

src/csharp/Grpc.Core/Utils/RecordingObserver.cs

@@ -57,9 +57,9 @@ namespace Grpc.Core.Utils
             data.Add(value);
         }
 
-        public Task<List<T>> ToList() {
+        public Task<List<T>> ToList()
+        {
             return tcs.Task;
         }
     }
 }
-

src/csharp/Grpc.Core/Utils/RecordingQueue.cs

@@ -32,9 +32,9 @@
 #endregion
 
 using System;
-using System.Threading.Tasks;
-using System.Collections.Generic;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace Grpc.Core.Utils
 {
@@ -81,4 +81,3 @@ namespace Grpc.Core.Utils
         }
     }
 }
-

src/csharp/Grpc.Core/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="System.Collections.Immutable" version="1.1.34-rc" targetFramework="net45" />
+</packages>

src/csharp/Grpc.Examples.MathClient/Properties/AssemblyInfo.cs

@@ -1,22 +1,12 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
-[assembly: AssemblyTitle ("Grpc.Examples.MathClient")]
-[assembly: AssemblyDescription ("")]
-[assembly: AssemblyConfiguration ("")]
-[assembly: AssemblyCompany ("")]
-[assembly: AssemblyProduct ("")]
-[assembly: AssemblyCopyright ("Google Inc.  All rights reserved.")]
-[assembly: AssemblyTrademark ("")]
-[assembly: AssemblyCulture ("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
-[assembly: AssemblyVersion ("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-
+[assembly: AssemblyTitle("Grpc.Examples.MathClient")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyVersion("0.1.*")]

src/csharp/Grpc.Examples.Tests/MathClientServerTests.cs

@@ -105,7 +105,7 @@ namespace math.Tests
             var recorder = new RecordingObserver<Num>();
             client.Fib(new FibArgs.Builder { Limit = 6 }.Build(), recorder);
 
-            CollectionAssert.AreEqual(new List<long>{1, 1, 2, 3, 5, 8},
+            CollectionAssert.AreEqual(new List<long> { 1, 1, 2, 3, 5, 8 },
                 recorder.ToList().Result.ConvertAll((n) => n.Num_));
         }
 
@@ -114,7 +114,8 @@ namespace math.Tests
         public void Sum()
         {
             var res = client.Sum();
-            foreach (var num in new long[] { 10, 20, 30 }) {
+            foreach (var num in new long[] { 10, 20, 30 })
+            {
                 res.Inputs.OnNext(Num.CreateBuilder().SetNum_(num).Build());
             }
             res.Inputs.OnCompleted();
@@ -125,7 +126,8 @@ namespace math.Tests
         [Test]
         public void DivMany()
         {
-            List<DivArgs> divArgsList = new List<DivArgs>{
+            List<DivArgs> divArgsList = new List<DivArgs>
+            {
                 new DivArgs.Builder { Dividend = 10, Divisor = 3 }.Build(),
                 new DivArgs.Builder { Dividend = 100, Divisor = 21 }.Build(),
                 new DivArgs.Builder { Dividend = 7, Divisor = 2 }.Build()
@@ -142,9 +144,8 @@ namespace math.Tests
 
             var result = recorder.ToList().Result;
 
-            CollectionAssert.AreEqual(new long[] {3, 4, 3}, result.ConvertAll((divReply) => divReply.Quotient));
-            CollectionAssert.AreEqual(new long[] {1, 16, 1}, result.ConvertAll((divReply) => divReply.Remainder));
+            CollectionAssert.AreEqual(new long[] { 3, 4, 3 }, result.ConvertAll((divReply) => divReply.Quotient));
+            CollectionAssert.AreEqual(new long[] { 1, 16, 1 }, result.ConvertAll((divReply) => divReply.Remainder));
         }
     }
 }
-

src/csharp/Grpc.Examples.Tests/Properties/AssemblyInfo.cs

@@ -1,8 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
 [assembly: AssemblyTitle("Grpc.Examples.Tests")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -11,12 +9,4 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
 [assembly: AssemblyVersion("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-

src/csharp/Grpc.Examples/MathExamples.cs

@@ -71,7 +71,8 @@ namespace math
         public static void SumExample(MathGrpc.IMathServiceClient stub)
         {
             List<Num> numbers = new List<Num>
-            {new Num.Builder { Num_ = 1 }.Build(),
+            {
+                new Num.Builder { Num_ = 1 }.Build(),
                 new Num.Builder { Num_ = 2 }.Build(),
                 new Num.Builder { Num_ = 3 }.Build()
             };
@@ -110,24 +111,12 @@ namespace math
         public static void DependendRequestsExample(MathGrpc.IMathServiceClient stub)
         {
             var numberList = new List<Num>
-            { new Num.Builder{ Num_ = 1 }.Build(),
-                new Num.Builder{ Num_ = 2 }.Build(), new Num.Builder{ Num_ = 3 }.Build()
+            {
+                new Num.Builder { Num_ = 1 }.Build(),
+                new Num.Builder { Num_ = 2 }.Build(), new Num.Builder { Num_ = 3 }.Build()
             };
 
             numberList.ToObservable();
-
-            //IObserver<Num> numbers;
-            //Task<Num> call = stub.Sum(out numbers);
-            //foreach (var num in numberList)
-            //{
-            //  numbers.OnNext(num);
-            //}
-            //numbers.OnCompleted();
-
-            //Num sum = call.Result;
-
-            //DivReply result = stub.Div(new DivArgs.Builder { Dividend = sum.Num_, Divisor = numberList.Count }.Build());
         }
     }
 }
-

src/csharp/Grpc.Examples/MathGrpc.cs

@@ -45,35 +45,34 @@ namespace math
     /// </summary>
     public class MathGrpc
     {
-        readonly static Marshaller<DivArgs> divArgsMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), DivArgs.ParseFrom);
-        readonly static Marshaller<DivReply> divReplyMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), DivReply.ParseFrom);
-        readonly static Marshaller<Num> numMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), Num.ParseFrom);
-        readonly static Marshaller<FibArgs> fibArgsMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), FibArgs.ParseFrom);
+        static readonly Marshaller<DivArgs> DivArgsMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), DivArgs.ParseFrom);
+        static readonly Marshaller<DivReply> DivReplyMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), DivReply.ParseFrom);
+        static readonly Marshaller<Num> NumMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), Num.ParseFrom);
+        static readonly Marshaller<FibArgs> FibArgsMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), FibArgs.ParseFrom);
 
-        readonly static Method<DivArgs, DivReply> divMethod = new Method<DivArgs, DivReply>(
+        static readonly Method<DivArgs, DivReply> DivMethod = new Method<DivArgs, DivReply>(
             MethodType.Unary,
             "/math.Math/Div",
-            divArgsMarshaller,
-            divReplyMarshaller
-        );
-        readonly static Method<FibArgs, Num> fibMethod = new Method<FibArgs, Num>(
+            DivArgsMarshaller,
+            DivReplyMarshaller);
+
+        static readonly Method<FibArgs, Num> FibMethod = new Method<FibArgs, Num>(
             MethodType.ServerStreaming,
             "/math.Math/Fib",
-            fibArgsMarshaller,
-            numMarshaller
-        );
-        readonly static Method<Num, Num> sumMethod = new Method<Num, Num>(
+            FibArgsMarshaller,
+            NumMarshaller);
+
+        static readonly Method<Num, Num> SumMethod = new Method<Num, Num>(
             MethodType.ClientStreaming,
             "/math.Math/Sum",
-            numMarshaller,
-            numMarshaller
-        );
-        readonly static Method<DivArgs, DivReply> divManyMethod = new Method<DivArgs, DivReply>(
+            NumMarshaller,
+            NumMarshaller);
+
+        static readonly Method<DivArgs, DivReply> DivManyMethod = new Method<DivArgs, DivReply>(
             MethodType.DuplexStreaming,
             "/math.Math/DivMany",
-            divArgsMarshaller,
-            divReplyMarshaller
-        );
+            DivArgsMarshaller,
+            DivReplyMarshaller);
 
         public interface IMathServiceClient
         {
@@ -99,31 +98,31 @@ namespace math
 
             public DivReply Div(DivArgs request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<DivArgs, DivReply>(divMethod, channel);
+                var call = new Grpc.Core.Call<DivArgs, DivReply>(DivMethod, channel);
                 return Calls.BlockingUnaryCall(call, request, token);
             }
 
             public Task<DivReply> DivAsync(DivArgs request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<DivArgs, DivReply>(divMethod, channel);
+                var call = new Grpc.Core.Call<DivArgs, DivReply>(DivMethod, channel);
                 return Calls.AsyncUnaryCall(call, request, token);
             }
 
             public void Fib(FibArgs request, IObserver<Num> responseObserver, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<FibArgs, Num>(fibMethod, channel);
+                var call = new Grpc.Core.Call<FibArgs, Num>(FibMethod, channel);
                 Calls.AsyncServerStreamingCall(call, request, responseObserver, token);
             }
 
             public ClientStreamingAsyncResult<Num, Num> Sum(CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<Num, Num>(sumMethod, channel);
+                var call = new Grpc.Core.Call<Num, Num>(SumMethod, channel);
                 return Calls.AsyncClientStreamingCall(call, token);
             }
 
             public IObserver<DivArgs> DivMany(IObserver<DivReply> responseObserver, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<DivArgs, DivReply>(divManyMethod, channel);
+                var call = new Grpc.Core.Call<DivArgs, DivReply>(DivManyMethod, channel);
                 return Calls.DuplexStreamingCall(call, responseObserver, token);
             }
         }
@@ -143,10 +142,10 @@ namespace math
         public static ServerServiceDefinition BindService(IMathService serviceImpl)
         {
             return ServerServiceDefinition.CreateBuilder("/math.Math/")
-                .AddMethod(divMethod, serviceImpl.Div)
-                .AddMethod(fibMethod, serviceImpl.Fib)
-                .AddMethod(sumMethod, serviceImpl.Sum)
-                .AddMethod(divManyMethod, serviceImpl.DivMany).Build();
+                .AddMethod(DivMethod, serviceImpl.Div)
+                .AddMethod(FibMethod, serviceImpl.Fib)
+                .AddMethod(SumMethod, serviceImpl.Sum)
+                .AddMethod(DivManyMethod, serviceImpl.DivMany).Build();
         }
 
         public static IMathServiceClient NewStub(Channel channel)

src/csharp/Grpc.Examples/MathServiceImpl.cs

@@ -73,8 +73,8 @@ namespace math
         public IObserver<Num> Sum(IObserver<Num> responseObserver)
         {
             var recorder = new RecordingObserver<Num>();
-            Task.Factory.StartNew(() => {
-
+            Task.Factory.StartNew(() =>
+            {
                 List<Num> inputs = recorder.ToList().Result;
 
                 long sum = 0;
@@ -104,7 +104,7 @@ namespace math
         static IEnumerable<Num> FibInternal(long n)
         {
             long a = 1;
-            yield return new Num.Builder { Num_=a }.Build();
+            yield return new Num.Builder { Num_ = a }.Build();
 
             long b = 1;
             for (long i = 0; i < n - 1; i++)
@@ -112,12 +112,12 @@ namespace math
                 long temp = a;
                 a = b;
                 b = temp + b;
-                yield return new Num.Builder { Num_=a }.Build();
+                yield return new Num.Builder { Num_ = a }.Build();
             }
         }
 
-        private class DivObserver : IObserver<DivArgs> {
-
+        private class DivObserver : IObserver<DivArgs>
+        {
             readonly IObserver<DivReply> responseObserver;
 
             public DivObserver(IObserver<DivReply> responseObserver)
@@ -142,4 +142,3 @@ namespace math
         }
     }
 }
-

src/csharp/Grpc.Examples/Properties/AssemblyInfo.cs

@@ -1,22 +1,12 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
-[assembly: AssemblyTitle ("Grpc.Examples")]
-[assembly: AssemblyDescription ("")]
-[assembly: AssemblyConfiguration ("")]
-[assembly: AssemblyCompany ("")]
-[assembly: AssemblyProduct ("")]
-[assembly: AssemblyCopyright ("Google Inc.  All rights reserved.")]
-[assembly: AssemblyTrademark ("")]
-[assembly: AssemblyCulture ("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
-[assembly: AssemblyVersion ("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-
+[assembly: AssemblyTitle("Grpc.Examples")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyVersion("0.1.*")]

src/csharp/Grpc.Examples/Settings.StyleCop

@@ -0,0 +1,10 @@
+<StyleCopSettings Version="105">
+  <SourceFileList>
+    <SourceFile>Math.cs</SourceFile>
+    <Settings>
+    <GlobalSettings>
+      <BooleanProperty Name="RulesEnabledByDefault">False</BooleanProperty>
+    </GlobalSettings>
+    </Settings>
+  </SourceFileList>
+</StyleCopSettings>

src/csharp/Grpc.IntegrationTesting.Client/Properties/AssemblyInfo.cs

@@ -1,8 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes. 
-// Change them to the values specific to your project.
 [assembly: AssemblyTitle("Grpc.IntegrationTesting.Client")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -11,12 +9,4 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
 [assembly: AssemblyVersion("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly, 
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-

src/csharp/Grpc.IntegrationTesting.Server/Properties/AssemblyInfo.cs

@@ -1,8 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes. 
-// Change them to the values specific to your project.
 [assembly: AssemblyTitle("Grpc.IntegrationTesting.Server")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -11,12 +9,4 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
 [assembly: AssemblyVersion("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly, 
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-

src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj

@@ -39,6 +39,10 @@
     <Reference Include="Google.ProtocolBuffers">
       <HintPath>..\packages\Google.ProtocolBuffers.2.4.1.521\lib\net40\Google.ProtocolBuffers.dll</HintPath>
     </Reference>
+    <Reference Include="System.Collections.Immutable, Version=1.1.34.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\System.Collections.Immutable.1.1.34-rc\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -76,8 +80,5 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="proto\" />
-    <Folder Include="data\" />
-  </ItemGroup>
-</Project>
+  <ItemGroup />
+</Project>

src/csharp/Grpc.IntegrationTesting/InteropClient.cs

@@ -38,10 +38,10 @@ using System.IO;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Google.ProtocolBuffers;
+using grpc.testing;
 using Grpc.Core;
 using Grpc.Core.Utils;
 using NUnit.Framework;
-using grpc.testing;
 
 namespace Grpc.IntegrationTesting
 {
@@ -50,7 +50,7 @@ namespace Grpc.IntegrationTesting
         private class ClientOptions
         {
             public bool help;
-            public string serverHost= "127.0.0.1";
+            public string serverHost = "127.0.0.1";
             public string serverHostOverride = TestCredentials.DefaultHostOverride;
             public int? serverPort;
             public string testCase = "large_unary";
@@ -109,7 +109,7 @@ namespace Grpc.IntegrationTesting
             ChannelArgs channelArgs = null;
             if (!string.IsNullOrEmpty(options.serverHostOverride))
             {
-                channelArgs = ChannelArgs.NewBuilder()
+                channelArgs = ChannelArgs.CreateBuilder()
                     .AddString(ChannelArgs.SslTargetNameOverrideKey, options.serverHostOverride).Build();
             }
 
@@ -180,7 +180,7 @@ namespace Grpc.IntegrationTesting
         {
             Console.WriteLine("running client_streaming");
 
-            var bodySizes = new List<int>{27182, 8, 1828, 45904};
+            var bodySizes = new List<int> { 27182, 8, 1828, 45904 };
 
             var context = client.StreamingInputCall();
             foreach (var size in bodySizes)
@@ -199,7 +199,7 @@ namespace Grpc.IntegrationTesting
         {
             Console.WriteLine("running server_streaming");
 
-            var bodySizes = new List<int>{31415, 9, 2653, 58979};
+            var bodySizes = new List<int> { 31415, 9, 2653, 58979 };
 
             var request = StreamingOutputCallRequest.CreateBuilder()
                 .SetResponseType(PayloadType.COMPRESSABLE)
@@ -256,7 +256,6 @@ namespace Grpc.IntegrationTesting
             Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
             Assert.AreEqual(2653, response.Payload.Body.Length);
 
-
             inputs.OnNext(StreamingOutputCallRequest.CreateBuilder()
                           .SetResponseType(PayloadType.COMPRESSABLE)
                           .AddResponseParameters(ResponseParameters.CreateBuilder().SetSize(58979))
@@ -292,17 +291,18 @@ namespace Grpc.IntegrationTesting
         public static void RunBenchmarkEmptyUnary(TestServiceGrpc.ITestServiceClient client)
         {
             BenchmarkUtil.RunBenchmark(10000, 10000,
-                                       () => { client.EmptyCall(Empty.DefaultInstance);});
+                                       () => { client.EmptyCall(Empty.DefaultInstance); });
         }
 
-        private static Payload CreateZerosPayload(int size) {
+        private static Payload CreateZerosPayload(int size)
+        {
             return Payload.CreateBuilder().SetBody(ByteString.CopyFrom(new byte[size])).Build();
         }
 
         private static ClientOptions ParseArguments(string[] args)
         {
             var options = new ClientOptions();
-            foreach(string arg in args)
+            foreach (string arg in args)
             {
                 ParseArgument(arg, options);
                 if (options.help)

src/csharp/Grpc.IntegrationTesting/InteropClientServerTest.cs

@@ -35,10 +35,10 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using grpc.testing;
 using Grpc.Core;
 using Grpc.Core.Utils;
 using NUnit.Framework;
-using grpc.testing;
 
 namespace Grpc.IntegrationTesting
 {
@@ -62,7 +62,7 @@ namespace Grpc.IntegrationTesting
             int port = server.AddPort(host + ":0", TestCredentials.CreateTestServerCredentials());
             server.Start();
 
-            var channelArgs = ChannelArgs.NewBuilder()
+            var channelArgs = ChannelArgs.CreateBuilder()
                 .AddString(ChannelArgs.SslTargetNameOverrideKey, TestCredentials.DefaultHostOverride).Build();
 
             channel = new Channel(host + ":" + port, TestCredentials.CreateTestClientCredentials(true), channelArgs);
@@ -117,7 +117,5 @@ namespace Grpc.IntegrationTesting
         // TODO: add cancel_after_begin
 
         // TODO: add cancel_after_first_response
-
     }
 }
-

src/csharp/Grpc.IntegrationTesting/InteropServer.cs

@@ -38,10 +38,10 @@ using System.IO;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Google.ProtocolBuffers;
+using grpc.testing;
 using Grpc.Core;
 using Grpc.Core.Utils;
 using NUnit.Framework;
-using grpc.testing;
 
 namespace Grpc.IntegrationTesting
 {
@@ -113,7 +113,7 @@ namespace Grpc.IntegrationTesting
         private static ServerOptions ParseArguments(string[] args)
         {
             var options = new ServerOptions();
-            foreach(string arg in args)
+            foreach (string arg in args)
             {
                 ParseArgument(arg, options);
                 if (options.help)

src/csharp/Grpc.IntegrationTesting/Properties/AssemblyInfo.cs

@@ -1,8 +1,6 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 
-// Information about this assembly is defined by the following attributes.
-// Change them to the values specific to your project.
 [assembly: AssemblyTitle("Grpc.IntegrationTesting")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -11,12 +9,4 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyCopyright("Google Inc.  All rights reserved.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
-// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
-// The form "{Major}.{Minor}.*" will automatically update the build and revision,
-// and "{Major}.{Minor}.{Build}.*" will update just the revision.
 [assembly: AssemblyVersion("0.1.*")]
-// The following attributes are used to specify the signing key for the assembly,
-// if desired. See the Mono documentation for more information about signing.
-//[assembly: AssemblyDelaySign(false)]
-//[assembly: AssemblyKeyFile("")]
-

src/csharp/Grpc.IntegrationTesting/Settings.StyleCop

@@ -0,0 +1,11 @@
+<StyleCopSettings Version="105">
+  <SourceFileList>
+    <SourceFile>Messages.cs</SourceFile>
+    <SourceFile>Empty.cs</SourceFile>
+    <Settings>
+    <GlobalSettings>
+      <BooleanProperty Name="RulesEnabledByDefault">False</BooleanProperty>
+    </GlobalSettings>
+    </Settings>
+  </SourceFileList>
+</StyleCopSettings>

src/csharp/Grpc.IntegrationTesting/TestCredentials.cs

@@ -33,15 +33,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.IO;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Google.ProtocolBuffers;
+using grpc.testing;
 using Grpc.Core;
 using Grpc.Core.Utils;
 using NUnit.Framework;
-using grpc.testing;
 
 namespace Grpc.IntegrationTesting
 {
@@ -77,7 +78,7 @@ namespace Grpc.IntegrationTesting
             var keyCertPair = new KeyCertificatePair(
                 File.ReadAllText(ServerCertChainPath),
                 File.ReadAllText(ServerPrivateKeyPath));
-            return new SslServerCredentials(new List<KeyCertificatePair> {keyCertPair});
+            return new SslServerCredentials(ImmutableList.Create(keyCertPair));
         }
     }
 }

src/csharp/Grpc.IntegrationTesting/TestServiceGrpc.cs

@@ -44,50 +44,49 @@ namespace grpc.testing
     /// </summary>
     public class TestServiceGrpc
     {
-        readonly static Marshaller<Empty> emptyMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), Empty.ParseFrom);
-        readonly static Marshaller<SimpleRequest> simpleRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleRequest.ParseFrom);
-        readonly static Marshaller<SimpleResponse> simpleResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleResponse.ParseFrom);
-        readonly static Marshaller<StreamingOutputCallRequest> streamingOutputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallRequest.ParseFrom);
-        readonly static Marshaller<StreamingOutputCallResponse> streamingOutputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallResponse.ParseFrom);
-        readonly static Marshaller<StreamingInputCallRequest> streamingInputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallRequest.ParseFrom);
-        readonly static Marshaller<StreamingInputCallResponse> streamingInputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallResponse.ParseFrom);
-
-        readonly static Method<Empty, Empty> emptyCallMethod = new Method<Empty, Empty>(
+        static readonly Marshaller<Empty> EmptyMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), Empty.ParseFrom);
+        static readonly Marshaller<SimpleRequest> SimpleRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleRequest.ParseFrom);
+        static readonly Marshaller<SimpleResponse> SimpleResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), SimpleResponse.ParseFrom);
+        static readonly Marshaller<StreamingOutputCallRequest> StreamingOutputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallRequest.ParseFrom);
+        static readonly Marshaller<StreamingOutputCallResponse> StreamingOutputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingOutputCallResponse.ParseFrom);
+        static readonly Marshaller<StreamingInputCallRequest> StreamingInputCallRequestMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallRequest.ParseFrom);
+        static readonly Marshaller<StreamingInputCallResponse> StreamingInputCallResponseMarshaller = Marshallers.Create((arg) => arg.ToByteArray(), StreamingInputCallResponse.ParseFrom);
+
+        static readonly Method<Empty, Empty> EmptyCallMethod = new Method<Empty, Empty>(
             MethodType.Unary,
             "/grpc.testing.TestService/EmptyCall",
-            emptyMarshaller,
-            emptyMarshaller
-        );
-        readonly static Method<SimpleRequest, SimpleResponse> unaryCallMethod = new Method<SimpleRequest, SimpleResponse>(
+            EmptyMarshaller,
+            EmptyMarshaller);
+
+        static readonly Method<SimpleRequest, SimpleResponse> UnaryCallMethod = new Method<SimpleRequest, SimpleResponse>(
             MethodType.Unary,
             "/grpc.testing.TestService/UnaryCall",
-            simpleRequestMarshaller,
-            simpleResponseMarshaller
-        );
-        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> streamingOutputCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            SimpleRequestMarshaller,
+            SimpleResponseMarshaller);
+
+        static readonly Method<StreamingOutputCallRequest, StreamingOutputCallResponse> StreamingOutputCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
             MethodType.ServerStreaming,
             "/grpc.testing.TestService/StreamingOutputCall",
-            streamingOutputCallRequestMarshaller,
-            streamingOutputCallResponseMarshaller
-            );
-        readonly static Method<StreamingInputCallRequest, StreamingInputCallResponse> streamingInputCallMethod = new Method<StreamingInputCallRequest, StreamingInputCallResponse>(
+            StreamingOutputCallRequestMarshaller,
+            StreamingOutputCallResponseMarshaller);
+
+        static readonly Method<StreamingInputCallRequest, StreamingInputCallResponse> StreamingInputCallMethod = new Method<StreamingInputCallRequest, StreamingInputCallResponse>(
             MethodType.ClientStreaming,
             "/grpc.testing.TestService/StreamingInputCall",
-            streamingInputCallRequestMarshaller,
-            streamingInputCallResponseMarshaller
-            );
-        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> fullDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            StreamingInputCallRequestMarshaller,
+            StreamingInputCallResponseMarshaller);
+
+        static readonly Method<StreamingOutputCallRequest, StreamingOutputCallResponse> FullDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
             MethodType.DuplexStreaming,
             "/grpc.testing.TestService/FullDuplexCall",
-            streamingOutputCallRequestMarshaller,
-            streamingOutputCallResponseMarshaller
-            );
-        readonly static Method<StreamingOutputCallRequest, StreamingOutputCallResponse> halfDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
+            StreamingOutputCallRequestMarshaller,
+            StreamingOutputCallResponseMarshaller);
+
+        static readonly Method<StreamingOutputCallRequest, StreamingOutputCallResponse> HalfDuplexCallMethod = new Method<StreamingOutputCallRequest, StreamingOutputCallResponse>(
             MethodType.DuplexStreaming,
             "/grpc.testing.TestService/HalfDuplexCall",
-            streamingOutputCallRequestMarshaller,
-            streamingOutputCallResponseMarshaller
-            );
+            StreamingOutputCallRequestMarshaller,
+            StreamingOutputCallResponseMarshaller);
 
         public interface ITestServiceClient
         {
@@ -119,49 +118,49 @@ namespace grpc.testing
 
             public Empty EmptyCall(Empty request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<Empty, Empty>(emptyCallMethod, channel);
+                var call = new Grpc.Core.Call<Empty, Empty>(EmptyCallMethod, channel);
                 return Calls.BlockingUnaryCall(call, request, token);
             }
 
             public Task<Empty> EmptyCallAsync(Empty request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<Empty, Empty>(emptyCallMethod, channel);
+                var call = new Grpc.Core.Call<Empty, Empty>(EmptyCallMethod, channel);
                 return Calls.AsyncUnaryCall(call, request, token);
             }
 
             public SimpleResponse UnaryCall(SimpleRequest request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(unaryCallMethod, channel);
+                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(UnaryCallMethod, channel);
                 return Calls.BlockingUnaryCall(call, request, token);
             }
 
             public Task<SimpleResponse> UnaryCallAsync(SimpleRequest request, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(unaryCallMethod, channel);
+                var call = new Grpc.Core.Call<SimpleRequest, SimpleResponse>(UnaryCallMethod, channel);
                 return Calls.AsyncUnaryCall(call, request, token);
             }
 
-            public void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken)) {
-                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(streamingOutputCallMethod, channel);
+            public void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken))
+            {
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(StreamingOutputCallMethod, channel);
                 Calls.AsyncServerStreamingCall(call, request, responseObserver, token);
             }
 
             public ClientStreamingAsyncResult<StreamingInputCallRequest, StreamingInputCallResponse> StreamingInputCall(CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<StreamingInputCallRequest, StreamingInputCallResponse>(streamingInputCallMethod, channel);
+                var call = new Grpc.Core.Call<StreamingInputCallRequest, StreamingInputCallResponse>(StreamingInputCallMethod, channel);
                 return Calls.AsyncClientStreamingCall(call, token);
             }
 
             public IObserver<StreamingOutputCallRequest> FullDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(fullDuplexCallMethod, channel);
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(FullDuplexCallMethod, channel);
                 return Calls.DuplexStreamingCall(call, responseObserver, token);
             }
 
-
             public IObserver<StreamingOutputCallRequest> HalfDuplexCall(IObserver<StreamingOutputCallResponse> responseObserver, CancellationToken token = default(CancellationToken))
             {
-                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(halfDuplexCallMethod, channel);
+                var call = new Grpc.Core.Call<StreamingOutputCallRequest, StreamingOutputCallResponse>(HalfDuplexCallMethod, channel);
                 return Calls.DuplexStreamingCall(call, responseObserver, token);
             }
         }
@@ -185,12 +184,12 @@ namespace grpc.testing
         public static ServerServiceDefinition BindService(ITestService serviceImpl)
         {
             return ServerServiceDefinition.CreateBuilder("/grpc.testing.TestService/")
-                .AddMethod(emptyCallMethod, serviceImpl.EmptyCall)
-                .AddMethod(unaryCallMethod, serviceImpl.UnaryCall)
-                .AddMethod(streamingOutputCallMethod, serviceImpl.StreamingOutputCall)
-                .AddMethod(streamingInputCallMethod, serviceImpl.StreamingInputCall)
-                .AddMethod(fullDuplexCallMethod, serviceImpl.FullDuplexCall)
-                .AddMethod(halfDuplexCallMethod, serviceImpl.HalfDuplexCall)
+                .AddMethod(EmptyCallMethod, serviceImpl.EmptyCall)
+                .AddMethod(UnaryCallMethod, serviceImpl.UnaryCall)
+                .AddMethod(StreamingOutputCallMethod, serviceImpl.StreamingOutputCall)
+                .AddMethod(StreamingInputCallMethod, serviceImpl.StreamingInputCall)
+                .AddMethod(FullDuplexCallMethod, serviceImpl.FullDuplexCall)
+                .AddMethod(HalfDuplexCallMethod, serviceImpl.HalfDuplexCall)
                 .Build();
         }
 

src/csharp/Grpc.IntegrationTesting/TestServiceImpl.cs

@@ -55,14 +55,14 @@ namespace grpc.testing
         {
             var response = SimpleResponse.CreateBuilder()
                 .SetPayload(CreateZerosPayload(request.ResponseSize)).Build();
-            //TODO: check we support ReponseType
+            // TODO: check we support ReponseType
             responseObserver.OnNext(response);
             responseObserver.OnCompleted();
         }
 
         public void StreamingOutputCall(StreamingOutputCallRequest request, IObserver<StreamingOutputCallResponse> responseObserver)
         {
-            foreach(var responseParam in request.ResponseParametersList)
+            foreach (var responseParam in request.ResponseParametersList)
             {
                 var response = StreamingOutputCallResponse.CreateBuilder()
                     .SetPayload(CreateZerosPayload(responseParam.Size)).Build();
@@ -74,9 +74,10 @@ namespace grpc.testing
         public IObserver<StreamingInputCallRequest> StreamingInputCall(IObserver<StreamingInputCallResponse> responseObserver)
         {
             var recorder = new RecordingObserver<StreamingInputCallRequest>();
-            Task.Run(() => {
+            Task.Run(() =>
+            {
                 int sum = 0;
-                foreach(var req in recorder.ToList().Result)
+                foreach (var req in recorder.ToList().Result)
                 {
                     sum += req.Payload.Body.Length;
                 }
@@ -98,8 +99,8 @@ namespace grpc.testing
             throw new NotImplementedException();
         }
 
-        private class FullDuplexObserver : IObserver<StreamingOutputCallRequest> {
-
+        private class FullDuplexObserver : IObserver<StreamingOutputCallRequest>
+        {
             readonly IObserver<StreamingOutputCallResponse> responseObserver;
 
             public FullDuplexObserver(IObserver<StreamingOutputCallResponse> responseObserver)
@@ -119,22 +120,18 @@ namespace grpc.testing
 
             public void OnNext(StreamingOutputCallRequest value)
             {
-                // TODO: this is not in order!!!
-                //Task.Factory.StartNew(() => {
-
-                    foreach(var responseParam in value.ResponseParametersList)
-                    {
-                        var response = StreamingOutputCallResponse.CreateBuilder()
-                            .SetPayload(CreateZerosPayload(responseParam.Size)).Build();
-                        responseObserver.OnNext(response);
-                    }
-                //});
+                foreach (var responseParam in value.ResponseParametersList)
+                {
+                    var response = StreamingOutputCallResponse.CreateBuilder()
+                        .SetPayload(CreateZerosPayload(responseParam.Size)).Build();
+                    responseObserver.OnNext(response);
+                }
             }
         }
 
-        private static Payload CreateZerosPayload(int size) {
+        private static Payload CreateZerosPayload(int size)
+        {
             return Payload.CreateBuilder().SetBody(ByteString.CopyFrom(new byte[size])).Build();
         }
     }
 }
-

src/csharp/Grpc.IntegrationTesting/packages.config

@@ -2,4 +2,5 @@
 <packages>
   <package id="Google.ProtocolBuffers" version="2.4.1.521" targetFramework="net45" />
   <package id="NUnit" version="2.6.4" targetFramework="net45" />
+  <package id="System.Collections.Immutable" version="1.1.34-rc" targetFramework="net45" />
 </packages>

src/csharp/Settings.StyleCop

@@ -0,0 +1,509 @@
+<StyleCopSettings Version="105">
+  <Analyzers>
+    <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
+      <Rules>
+        <Rule Name="ElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="EnumerationItemsMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustContainValidXml">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PartialElementDocumentationMustHaveSummaryText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotHaveDefaultSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustMatchElementParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementReturnValueDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="VoidReturnValueMustNotBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumented">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParametersMustBeDocumentedPartialClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustMatchTypeParameters">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustDeclareParameterName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="GenericTypeParameterDocumentationMustHaveText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustMatchAccessors">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustNotBeCopiedAndPasted">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="SingleLineCommentsMustNotUseDocumentationStyleSlashes">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustNotBeEmpty">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustContainWhitespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationMustMeetCharacterPercentage">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ConstructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DestructorSummaryDocumentationMustBeginWithStandardText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationHeadersMustNotContainBlankLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludedDocumentationXPathDoesNotExist">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="IncludeNodeDoesNotContainValidFileAndPath">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="InheritDocMustBeUsedWithInheritingClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationMustBeSpelledCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMustHaveHeader">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustShowCopyright">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveCopyrightText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustContainFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchFileName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveValidCompanyText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderFileNameDocumentationMustMatchTypeName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
+      <Rules>
+        <Rule Name="AccessModifierMustBeDeclared">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldsMustBePrivate">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CodeAnalysisSuppressionMustHaveJustification">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DebugAssertMustProvideMessageText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DebugFailMustProvideMessageText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileMayOnlyContainASingleClass">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="StatementMustNotUseUnnecessaryParenthesis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ArithmeticExpressionsMustDeclarePrecedence">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ConditionalExpressionsMustDeclarePrecedence">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="RemoveDelegateParenthesisWhenPossible">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="AttributeConstructorMustNotUseUnnecessaryParenthesis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="RemoveUnnecessaryCode">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.NamingRules">
+      <Rules>
+        <Rule Name="NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldNamesMustNotUseHungarianNotation">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldNamesMustBeginWithLowerCaseLetter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="AccessibleFieldsMustBeginWithUpperCaseLetter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="VariableNamesMustNotBePrefixed">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldNamesMustNotBeginWithUnderscore">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FieldNamesMustNotContainUnderscore">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementMustBeginWithUpperCaseLetter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
+      <Rules>
+        <Rule Name="UsingDirectivesMustBePlacedWithinNamespace">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustAppearInTheCorrectOrder">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementsMustBeOrderedByAccess">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="StaticElementsMustAppearBeforeInstanceElements">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertyAccessorsMustFollowOrder">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="EventAccessorsMustFollowOrder">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
+      <Rules>
+        <Rule Name="DoNotPrefixCallsWithBaseUnlessLocalImplementationExists">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixLocalCallsWithThis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PrefixCallsCorrectly">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="OpeningParenthesisMustBeOnDeclarationLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ClosingParenthesisMustBeOnLineOfLastParameter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ClosingParenthesisMustBeOnLineOfOpeningParenthesis">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CommaMustBeOnSameLineAsPreviousParameter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParameterListMustFollowDeclaration">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParameterMustFollowComma">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="SplitParametersMustStartOnLineAfterDeclaration">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParametersMustBeOnSameLineOrSeparateLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ParameterMustNotSpanMultipleLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="QueryClauseMustFollowPreviousClause">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="QueryClausesMustBeOnSeparateLinesOrAllOnOneLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="QueryClauseMustBeginOnNewLineWhenPreviousClauseSpansMultipleLines">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="QueryClausesSpanningMultipleLinesMustBeginOnOwnLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CodeMustNotContainEmptyStatements">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="CodeMustNotContainMultipleStatementsOnOneLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="BlockStatementsMustNotContainEmbeddedComments">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="BlockStatementsMustNotContainEmbeddedRegions">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="UseStringEmptyForEmptyStrings">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
+      <Rules>
+        <Rule Name="SingleLineCommentsMustNotBeFollowedByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ClosingCurlyBracketMustBeFollowedByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="ElementDocumentationHeaderMustBePrecededByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="SingleLineCommentMustBePrecededByBlankLine">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">False</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+  </Analyzers>
+</StyleCopSettings>

src/node/README.md

@@ -10,9 +10,9 @@ This requires `node` to be installed. If you instead have the `nodejs` executabl
 
 ## Installation
 
-First, clone this repository (NPM package coming soon). Then follow the instructions in the `INSTALL` file in the root of the repository to install the C core library that this package depends on.
-
-Then, simply run `npm install` in or referencing this directory.
+ 1. Clone [the grpc repository](https://github.com/grpc/grpc).
+ 2. Follow the instructions in the `INSTALL` file in the root of that repository to install the C core library that this package depends on.
+ 3. Run `npm install`.
 
 ## Tests
 

src/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grpc",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "author": "Google Inc.",
   "description": "gRPC Library for Node",
   "homepage": "http://www.grpc.io/",
@@ -26,7 +26,7 @@
   "dependencies": {
     "bindings": "^1.2.0",
     "nan": "^1.5.0",
-    "protobufjs": "murgatroid99/ProtoBuf.js",
+    "protobufjs": "^4.0.0-b2",
     "underscore": "^1.6.0",
     "underscore.string": "^3.0.0"
   },

src/php/ext/grpc/call.c

@@ -56,6 +56,8 @@
 #include "completion_queue.h"
 #include "byte_buffer.h"
 
+zend_class_entry *grpc_ce_call;
+
 /* Frees and destroys an instance of wrapped_grpc_call */
 void free_wrapped_grpc_call(void *object TSRMLS_DC) {
   wrapped_grpc_call *call = (wrapped_grpc_call *)object;

src/php/ext/grpc/call.h

@@ -57,7 +57,7 @@
   } while (0)
 
 /* Class entry for the Call PHP class */
-zend_class_entry *grpc_ce_call;
+extern zend_class_entry *grpc_ce_call;
 
 /* Wrapper struct for grpc_call that can be associated with a PHP object */
 typedef struct wrapped_grpc_call {

src/php/ext/grpc/channel.c

@@ -55,6 +55,8 @@
 #include "server.h"
 #include "credentials.h"
 
+zend_class_entry *grpc_ce_channel;
+
 /* Frees and destroys an instance of wrapped_grpc_channel */
 void free_wrapped_grpc_channel(void *object TSRMLS_DC) {
   wrapped_grpc_channel *channel = (wrapped_grpc_channel *)object;

src/php/ext/grpc/channel.h

@@ -46,7 +46,7 @@
 #include "grpc/grpc.h"
 
 /* Class entry for the PHP Channel class */
-zend_class_entry *grpc_ce_channel;
+extern zend_class_entry *grpc_ce_channel;
 
 /* Wrapper struct for grpc_channel that can be associated with a PHP object */
 typedef struct wrapped_grpc_channel {

src/php/ext/grpc/completion_queue.c

@@ -52,6 +52,8 @@
 #include "event.h"
 #include "timeval.h"
 
+zend_class_entry *grpc_ce_completion_queue;
+
 /* Frees and destroys a wrapped instance of grpc_completion_queue */
 void free_wrapped_grpc_completion_queue(void *object TSRMLS_DC) {
   wrapped_grpc_completion_queue *queue = NULL;