Merge branch 'travis-c++' of github.com:ctiller/grpc into travis-c++

.travis.yml

@@ -1,4 +1,12 @@
 language: cpp
-script: ./tools/run_tests/run_tests.py -lc -t -j2
+before_install:
+  - sudo add-apt-repository ppa:yjwong/gflags -y
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq libgtest-dev libgflags-dev
+script:
+  - ./tools/run_tests/run_tests.py -l c -t -j 8 -c dbg
+  - ./tools/run_tests/run_tests.py -l c -t -j 8 -c opt
+  - ./tools/run_tests/run_tests.py -l c++ -t -j 8 -c dbg
+  - ./tools/run_tests/run_tests.py -l c++ -t -j 8 -c opt
 notifications:
   email: false

Makefile

@@ -152,6 +152,10 @@ $(error Invalid CONFIG value '$(CONFIG)')
 endif
 
 
+# Detect if we can use C++11
+CXX11_CHECK_CMD = $(CXX) -std=c++11 -o /dev/null -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.
 # In most cases, you won't have to change anything, but if you are
 # cross-compiling, you can override these variables from GNU make's
@@ -167,7 +171,12 @@ DEFINES += $(DEFINES_$(CONFIG)) INSTALL_PREFIX=\"$(prefix)\"
 LDFLAGS += $(LDFLAGS_$(CONFIG))
 
 CFLAGS += -std=c89 -pedantic
+ifeq ($(HAS_CXX11),true)
 CXXFLAGS += -std=c++11
+else
+CXXFLAGS += -std=c++0x
+DEFINES += GRPC_OLD_CXX
+endif
 CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter
 LDFLAGS += -g -fPIC
 
@@ -897,7 +906,11 @@ third_party/protobuf/configure:
 
 $(LIBDIR)/$(CONFIG)/protobuf/libprotobuf.a: third_party/protobuf/configure
 	$(E) "[MAKE]    Building protobuf"
+ifeq ($(HAVE_CXX11),true)
 	$(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-DLANG_CXX11 -std=c++11" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static)
+else
+	$(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-std=c++0x" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static)
+endif
 	$(Q)$(MAKE) -C third_party/protobuf clean
 	$(Q)$(MAKE) -C third_party/protobuf
 	$(Q)mkdir -p $(LIBDIR)/$(CONFIG)/protobuf

examples/pubsub/publisher_test.cc

@@ -61,28 +61,28 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service {
  public:
   Status CreateTopic(::grpc::ServerContext* context,
                      const ::tech::pubsub::Topic* request,
-                     ::tech::pubsub::Topic* response) override {
+                     ::tech::pubsub::Topic* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->name(), kTopic);
     return Status::OK;
   }
 
   Status Publish(ServerContext* context,
                  const ::tech::pubsub::PublishRequest* request,
-                 ::proto2::Empty* response) override {
+                 ::proto2::Empty* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->message().data(), kMessageData);
     return Status::OK;
   }
 
   Status GetTopic(ServerContext* context,
                   const ::tech::pubsub::GetTopicRequest* request,
-                  ::tech::pubsub::Topic* response) override {
+                  ::tech::pubsub::Topic* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->topic(), kTopic);
     return Status::OK;
   }
 
- Status ListTopics(ServerContext* context,
-                   const ::tech::pubsub::ListTopicsRequest* request,
-                   ::tech::pubsub::ListTopicsResponse* response) override {
+  Status ListTopics(
+      ServerContext* context, const ::tech::pubsub::ListTopicsRequest* request,
+      ::tech::pubsub::ListTopicsResponse* response) GRPC_OVERRIDE {
    std::ostringstream ss;
    ss << "cloud.googleapis.com/project in (/projects/" << kProjectId << ")";
    EXPECT_EQ(request->query(), ss.str());
@@ -92,7 +92,7 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service {
 
  Status DeleteTopic(ServerContext* context,
                     const ::tech::pubsub::DeleteTopicRequest* request,
-                    ::proto2::Empty* response) override {
+                    ::proto2::Empty* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->topic(), kTopic);
     return Status::OK;
  }
@@ -102,7 +102,7 @@ class PublisherServiceImpl : public tech::pubsub::PublisherService::Service {
 class PublisherTest : public ::testing::Test {
  protected:
   // Setup a server and a client for PublisherService.
-  void SetUp() override {
+  void SetUp() GRPC_OVERRIDE {
     int port = grpc_pick_unused_port_or_die();
     server_address_ << "localhost:" << port;
     ServerBuilder builder;
@@ -116,7 +116,7 @@ class PublisherTest : public ::testing::Test {
     publisher_.reset(new grpc::examples::pubsub::Publisher(channel_));
   }
 
-  void TearDown() override {
+  void TearDown() GRPC_OVERRIDE {
     server_->Shutdown();
     publisher_->Shutdown();
   }

examples/pubsub/subscriber_test.cc

@@ -57,9 +57,9 @@ const char kData[] = "Message data";
 
 class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service {
  public:
-  Status CreateSubscription(ServerContext* context,
-                            const tech::pubsub::Subscription* request,
-                            tech::pubsub::Subscription* response) override {
+  Status CreateSubscription(
+      ServerContext* context, const tech::pubsub::Subscription* request,
+      tech::pubsub::Subscription* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->topic(), kTopic);
     EXPECT_EQ(request->name(), kSubscriptionName);
     return Status::OK;
@@ -67,7 +67,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service {
 
   Status GetSubscription(ServerContext* context,
                          const tech::pubsub::GetSubscriptionRequest* request,
-                         tech::pubsub::Subscription* response) override {
+                         tech::pubsub::Subscription* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->subscription(), kSubscriptionName);
     response->set_topic(kTopic);
     return Status::OK;
@@ -76,14 +76,13 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service {
   Status DeleteSubscription(
       ServerContext* context,
       const tech::pubsub::DeleteSubscriptionRequest* request,
-      proto2::Empty* response) override {
+      proto2::Empty* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->subscription(), kSubscriptionName);
     return Status::OK;
   }
 
-  Status Pull(ServerContext* context,
-              const tech::pubsub::PullRequest* request,
-              tech::pubsub::PullResponse* response) override {
+  Status Pull(ServerContext* context, const tech::pubsub::PullRequest* request,
+              tech::pubsub::PullResponse* response) GRPC_OVERRIDE {
     EXPECT_EQ(request->subscription(), kSubscriptionName);
     response->set_ack_id("1");
     response->mutable_pubsub_event()->mutable_message()->set_data(kData);
@@ -92,7 +91,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service {
 
   Status Acknowledge(ServerContext* context,
                      const tech::pubsub::AcknowledgeRequest* request,
-                     proto2::Empty* response) override {
+                     proto2::Empty* response) GRPC_OVERRIDE {
     return Status::OK;
   }
 
@@ -101,7 +100,7 @@ class SubscriberServiceImpl : public tech::pubsub::SubscriberService::Service {
 class SubscriberTest : public ::testing::Test {
  protected:
   // Setup a server and a client for SubscriberService.
-  void SetUp() override {
+  void SetUp() GRPC_OVERRIDE {
     int port = grpc_pick_unused_port_or_die();
     server_address_ << "localhost:" << port;
     ServerBuilder builder;
@@ -115,7 +114,7 @@ class SubscriberTest : public ::testing::Test {
     subscriber_.reset(new grpc::examples::pubsub::Subscriber(channel_));
   }
 
-  void TearDown() override {
+  void TearDown() GRPC_OVERRIDE {
     server_->Shutdown();
     subscriber_->Shutdown();
   }

include/grpc++/async_unary_call.h

@@ -45,7 +45,7 @@
 
 namespace grpc {
 template <class R>
-class ClientAsyncResponseReader final {
+class ClientAsyncResponseReader GRPC_FINAL {
  public:
   ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
@@ -79,7 +79,7 @@ class ClientAsyncResponseReader final {
 
 
  private:
-  ClientContext* context_ = nullptr;
+  ClientContext* context_;
   Call call_;
   CallOpBuffer init_buf_;
   CallOpBuffer meta_buf_;
@@ -87,7 +87,8 @@ class ClientAsyncResponseReader final {
 };
 
 template <class W>
-class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface {
+class ServerAsyncResponseWriter GRPC_FINAL
+    : public ServerAsyncStreamingInterface {
  public:
   explicit ServerAsyncResponseWriter(ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
@@ -127,7 +128,7 @@ class ServerAsyncResponseWriter final : public ServerAsyncStreamingInterface {
   }
 
  private:
-  void BindCall(Call* call) override { call_ = *call; }
+  void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; }
 
   Call call_;
   ServerContext* ctx_;

include/grpc++/client_context.h

@@ -139,7 +139,7 @@ class ClientContext {
     return authority_;
   }
 
-  bool initial_metadata_received_ = false;
+  bool initial_metadata_received_;
   grpc_call *call_;
   grpc_completion_queue *cq_;
   gpr_timespec absolute_deadline_;

include/grpc++/config.h

@@ -36,6 +36,14 @@
 
 #include <string>
 
+#ifdef GRPC_OLD_CXX
+#define GRPC_FINAL
+#define GRPC_OVERRIDE
+#else
+#define GRPC_FINAL final
+#define GRPC_OVERRIDE override
+#endif
+
 namespace grpc {
 
 typedef std::string string;

include/grpc++/credentials.h

@@ -47,7 +47,7 @@ namespace grpc {
 // to creating an instance using CredentialsFactory, and passing it down
 // during channel construction.
 
-class Credentials final {
+class Credentials GRPC_FINAL {
  public:
   ~Credentials();
 

include/grpc++/impl/call.h

@@ -35,6 +35,7 @@
 #define __GRPCPP_CALL_H__
 
 #include <grpc/grpc.h>
+#include <grpc++/config.h>
 #include <grpc++/status.h>
 #include <grpc++/completion_queue.h>
 
@@ -56,7 +57,7 @@ class Call;
 
 class CallOpBuffer : public CompletionQueueTag {
  public:
-  CallOpBuffer() : return_tag_(this) {}
+  CallOpBuffer();
   ~CallOpBuffer();
 
   void Reset(void *next_return_tag);
@@ -80,40 +81,40 @@ class CallOpBuffer : public CompletionQueueTag {
   void FillOps(grpc_op *ops, size_t *nops);
 
   // Called by completion queue just prior to returning from Next() or Pluck()
-  bool FinalizeResult(void **tag, bool *status) override;
+  bool FinalizeResult(void **tag, bool *status) GRPC_OVERRIDE;
 
-  bool got_message = false;
+  bool got_message;
 
  private:
-  void *return_tag_ = nullptr;
+  void *return_tag_;
   // Send initial metadata
-  bool send_initial_metadata_ = false;
-  size_t initial_metadata_count_ = 0;
-  grpc_metadata *initial_metadata_ = nullptr;
+  bool send_initial_metadata_;
+  size_t initial_metadata_count_;
+  grpc_metadata *initial_metadata_;
   // Recv initial metadta
-  std::multimap<grpc::string, grpc::string> *recv_initial_metadata_ = nullptr;
-  grpc_metadata_array recv_initial_metadata_arr_ = {0, 0, nullptr};
+  std::multimap<grpc::string, grpc::string> *recv_initial_metadata_;
+  grpc_metadata_array recv_initial_metadata_arr_;
   // Send message
-  const google::protobuf::Message *send_message_ = nullptr;
-  grpc_byte_buffer *send_message_buf_ = nullptr;
+  const google::protobuf::Message *send_message_;
+  grpc_byte_buffer *send_message_buf_;
   // Recv message
-  google::protobuf::Message *recv_message_ = nullptr;
-  grpc_byte_buffer *recv_message_buf_ = nullptr;
+  google::protobuf::Message *recv_message_;
+  grpc_byte_buffer *recv_message_buf_;
   // Client send close
-  bool client_send_close_ = false;
+  bool client_send_close_;
   // Client recv status
-  std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_ = nullptr;
-  Status *recv_status_ = nullptr;
-  grpc_metadata_array recv_trailing_metadata_arr_ = {0, 0, nullptr};
-  grpc_status_code status_code_ = GRPC_STATUS_OK;
-  char *status_details_ = nullptr;
-  size_t status_details_capacity_ = 0;
+  std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_;
+  Status *recv_status_;
+  grpc_metadata_array recv_trailing_metadata_arr_;
+  grpc_status_code status_code_;
+  char *status_details_;
+  size_t status_details_capacity_;
   // Server send status
-  const Status *send_status_ = nullptr;
-  size_t trailing_metadata_count_ = 0;
-  grpc_metadata *trailing_metadata_ = nullptr;
+  const Status *send_status_;
+  size_t trailing_metadata_count_;
+  grpc_metadata *trailing_metadata_;
   int cancelled_buf_;
-  bool *recv_closed_ = nullptr;
+  bool *recv_closed_;
 };
 
 // Channel and Server implement this to allow them to hook performing ops
@@ -124,7 +125,7 @@ class CallHook {
 };
 
 // Straightforward wrapping of the C call object
-class Call final {
+class Call GRPC_FINAL {
  public:
   /* call is owned by the caller */
   Call(grpc_call *call, CallHook *call_hook_, CompletionQueue *cq);

include/grpc++/impl/rpc_service_method.h

@@ -77,7 +77,7 @@ class RpcMethodHandler : public MethodHandler {
       ServiceType* service)
       : func_(func), service_(service) {}
 
-  Status RunHandler(const HandlerParameter& param) final {
+  Status RunHandler(const HandlerParameter& param) GRPC_FINAL {
     // Invoke application function, cast proto messages to their actual types.
     return func_(service_, param.server_context,
                  dynamic_cast<const RequestType*>(param.request),
@@ -102,7 +102,7 @@ class ClientStreamingHandler : public MethodHandler {
       ServiceType* service)
       : func_(func), service_(service) {}
 
-  Status RunHandler(const HandlerParameter& param) final {
+  Status RunHandler(const HandlerParameter& param) GRPC_FINAL {
     ServerReader<RequestType> reader(param.call, param.server_context);
     return func_(service_, param.server_context, &reader,
                  dynamic_cast<ResponseType*>(param.response));
@@ -124,7 +124,7 @@ class ServerStreamingHandler : public MethodHandler {
       ServiceType* service)
       : func_(func), service_(service) {}
 
-  Status RunHandler(const HandlerParameter& param) final {
+  Status RunHandler(const HandlerParameter& param) GRPC_FINAL {
     ServerWriter<ResponseType> writer(param.call, param.server_context);
     return func_(service_, param.server_context,
                  dynamic_cast<const RequestType*>(param.request), &writer);
@@ -147,7 +147,7 @@ class BidiStreamingHandler : public MethodHandler {
       ServiceType* service)
       : func_(func), service_(service) {}
 
-  Status RunHandler(const HandlerParameter& param) final {
+  Status RunHandler(const HandlerParameter& param) GRPC_FINAL {
     ServerReaderWriter<ResponseType, RequestType> stream(param.call,
                                                          param.server_context);
     return func_(service_, param.server_context, &stream);

include/grpc++/impl/service_type.h

@@ -79,7 +79,11 @@ class AsynchronousService {
 
   AsynchronousService(CompletionQueue* cq, const char** method_names,
                       size_t method_count)
-      : cq_(cq), method_names_(method_names), method_count_(method_count) {}
+      : cq_(cq),
+        dispatch_impl_(nullptr),
+        method_names_(method_names),
+        method_count_(method_count),
+        request_args_(nullptr) {}
 
   ~AsynchronousService() { delete[] request_args_; }
 
@@ -116,10 +120,10 @@ class AsynchronousService {
  private:
   friend class Server;
   CompletionQueue* const cq_;
-  DispatchImpl* dispatch_impl_ = nullptr;
+  DispatchImpl* dispatch_impl_;
   const char** const method_names_;
   size_t method_count_;
-  void** request_args_ = nullptr;
+  void** request_args_;
 };
 
 }  // namespace grpc

include/grpc++/server.h

@@ -61,8 +61,8 @@ class ServerCredentials;
 class ThreadPoolInterface;
 
 // Currently it only supports handling rpcs in a single thread.
-class Server final : private CallHook,
-                     private AsynchronousService::DispatchImpl {
+class Server GRPC_FINAL : private CallHook,
+                          private AsynchronousService::DispatchImpl {
  public:
   ~Server();
 
@@ -97,7 +97,7 @@ class Server final : private CallHook,
   void RunRpc();
   void ScheduleCallback();
 
-  void PerformOpsOnCall(CallOpBuffer* ops, Call* call) override;
+  void PerformOpsOnCall(CallOpBuffer* ops, Call* call) GRPC_OVERRIDE;
 
   // DispatchImpl
   void RequestAsyncCall(void* registered_method, ServerContext* context,

include/grpc++/server_builder.h

@@ -83,7 +83,7 @@ class ServerBuilder {
   std::vector<AsynchronousService*> async_services_;
   std::vector<grpc::string> ports_;
   std::shared_ptr<ServerCredentials> creds_;
-  ThreadPoolInterface* thread_pool_ = nullptr;
+  ThreadPoolInterface* thread_pool_;
 };
 
 }  // namespace grpc

include/grpc++/server_context.h

@@ -66,7 +66,7 @@ class CompletionQueue;
 class Server;
 
 // Interface of server side rpc context.
-class ServerContext final {
+class ServerContext GRPC_FINAL {
  public:
   ServerContext();  // for async calls
   ~ServerContext();
@@ -108,12 +108,12 @@ class ServerContext final {
   ServerContext(gpr_timespec deadline, grpc_metadata* metadata,
                 size_t metadata_count);
 
-  CompletionOp* completion_op_ = nullptr;
+  CompletionOp* completion_op_;
 
   std::chrono::system_clock::time_point deadline_;
-  grpc_call* call_ = nullptr;
-  CompletionQueue* cq_ = nullptr;
-  bool sent_initial_metadata_ = false;
+  grpc_call* call_;
+  CompletionQueue* cq_;
+  bool sent_initial_metadata_;
   std::multimap<grpc::string, grpc::string> client_metadata_;
   std::multimap<grpc::string, grpc::string> initial_metadata_;
   std::multimap<grpc::string, grpc::string> trailing_metadata_;

include/grpc++/server_credentials.h

@@ -44,7 +44,7 @@ struct grpc_server_credentials;
 namespace grpc {
 
 // grpc_server_credentials wrapper class.
-class ServerCredentials final {
+class ServerCredentials GRPC_FINAL {
  public:
   ~ServerCredentials();
 

include/grpc++/stream.h

@@ -83,8 +83,8 @@ class WriterInterface {
 };
 
 template <class R>
-class ClientReader final : public ClientStreamingInterface,
-                           public ReaderInterface<R> {
+class ClientReader GRPC_FINAL : public ClientStreamingInterface,
+                                public ReaderInterface<R> {
  public:
   // Blocking create a stream and write the first request out.
   ClientReader(ChannelInterface* channel, const RpcMethod& method,
@@ -111,7 +111,7 @@ class ClientReader final : public ClientStreamingInterface,
     GPR_ASSERT(cq_.Pluck(&buf));
   }
 
-  virtual bool Read(R* msg) override {
+  virtual bool Read(R* msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     if (!context_->initial_metadata_received_) {
       buf.AddRecvInitialMetadata(context_);
@@ -121,7 +121,7 @@ class ClientReader final : public ClientStreamingInterface,
     return cq_.Pluck(&buf) && buf.got_message;
   }
 
-  virtual Status Finish() override {
+  virtual Status Finish() GRPC_OVERRIDE {
     CallOpBuffer buf;
     Status status;
     buf.AddClientRecvStatus(context_, &status);
@@ -137,8 +137,8 @@ class ClientReader final : public ClientStreamingInterface,
 };
 
 template <class W>
-class ClientWriter final : public ClientStreamingInterface,
-                           public WriterInterface<W> {
+class ClientWriter GRPC_FINAL : public ClientStreamingInterface,
+                                public WriterInterface<W> {
  public:
   // Blocking create a stream.
   ClientWriter(ChannelInterface* channel, const RpcMethod& method,
@@ -152,7 +152,7 @@ class ClientWriter final : public ClientStreamingInterface,
     cq_.Pluck(&buf);
   }
 
-  virtual bool Write(const W& msg) override {
+  virtual bool Write(const W& msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     buf.AddSendMessage(msg);
     call_.PerformOps(&buf);
@@ -167,7 +167,7 @@ class ClientWriter final : public ClientStreamingInterface,
   }
 
   // Read the final response and wait for the final status.
-  virtual Status Finish() override {
+  virtual Status Finish() GRPC_OVERRIDE {
     CallOpBuffer buf;
     Status status;
     buf.AddRecvMessage(response_);
@@ -186,9 +186,9 @@ class ClientWriter final : public ClientStreamingInterface,
 
 // Client-side interface for bi-directional streaming.
 template <class W, class R>
-class ClientReaderWriter final : public ClientStreamingInterface,
-                                 public WriterInterface<W>,
-                                 public ReaderInterface<R> {
+class ClientReaderWriter GRPC_FINAL : public ClientStreamingInterface,
+                                      public WriterInterface<W>,
+                                      public ReaderInterface<R> {
  public:
   // Blocking create a stream.
   ClientReaderWriter(ChannelInterface* channel, const RpcMethod& method,
@@ -213,7 +213,7 @@ class ClientReaderWriter final : public ClientStreamingInterface,
     GPR_ASSERT(cq_.Pluck(&buf));
   }
 
-  virtual bool Read(R* msg) override {
+  virtual bool Read(R* msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     if (!context_->initial_metadata_received_) {
       buf.AddRecvInitialMetadata(context_);
@@ -223,7 +223,7 @@ class ClientReaderWriter final : public ClientStreamingInterface,
     return cq_.Pluck(&buf) && buf.got_message;
   }
 
-  virtual bool Write(const W& msg) override {
+  virtual bool Write(const W& msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     buf.AddSendMessage(msg);
     call_.PerformOps(&buf);
@@ -237,7 +237,7 @@ class ClientReaderWriter final : public ClientStreamingInterface,
     return cq_.Pluck(&buf);
   }
 
-  virtual Status Finish() override {
+  virtual Status Finish() GRPC_OVERRIDE {
     CallOpBuffer buf;
     Status status;
     buf.AddClientRecvStatus(context_, &status);
@@ -253,7 +253,7 @@ class ClientReaderWriter final : public ClientStreamingInterface,
 };
 
 template <class R>
-class ServerReader final : public ReaderInterface<R> {
+class ServerReader GRPC_FINAL : public ReaderInterface<R> {
  public:
   ServerReader(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
 
@@ -267,7 +267,7 @@ class ServerReader final : public ReaderInterface<R> {
     call_->cq()->Pluck(&buf);
   }
 
-  virtual bool Read(R* msg) override {
+  virtual bool Read(R* msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     buf.AddRecvMessage(msg);
     call_->PerformOps(&buf);
@@ -280,7 +280,7 @@ class ServerReader final : public ReaderInterface<R> {
 };
 
 template <class W>
-class ServerWriter final : public WriterInterface<W> {
+class ServerWriter GRPC_FINAL : public WriterInterface<W> {
  public:
   ServerWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
 
@@ -294,7 +294,7 @@ class ServerWriter final : public WriterInterface<W> {
     call_->cq()->Pluck(&buf);
   }
 
-  virtual bool Write(const W& msg) override {
+  virtual bool Write(const W& msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     if (!ctx_->sent_initial_metadata_) {
       buf.AddSendInitialMetadata(&ctx_->initial_metadata_);
@@ -312,8 +312,8 @@ class ServerWriter final : public WriterInterface<W> {
 
 // Server-side interface for bi-directional streaming.
 template <class W, class R>
-class ServerReaderWriter final : public WriterInterface<W>,
-                                 public ReaderInterface<R> {
+class ServerReaderWriter GRPC_FINAL : public WriterInterface<W>,
+                                      public ReaderInterface<R> {
  public:
   ServerReaderWriter(Call* call, ServerContext* ctx) : call_(call), ctx_(ctx) {}
 
@@ -327,14 +327,14 @@ class ServerReaderWriter final : public WriterInterface<W>,
     call_->cq()->Pluck(&buf);
   }
 
-  virtual bool Read(R* msg) override {
+  virtual bool Read(R* msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     buf.AddRecvMessage(msg);
     call_->PerformOps(&buf);
     return call_->cq()->Pluck(&buf) && buf.got_message;
   }
 
-  virtual bool Write(const W& msg) override {
+  virtual bool Write(const W& msg) GRPC_OVERRIDE {
     CallOpBuffer buf;
     if (!ctx_->sent_initial_metadata_) {
       buf.AddSendInitialMetadata(&ctx_->initial_metadata_);
@@ -380,8 +380,8 @@ class AsyncWriterInterface {
 };
 
 template <class R>
-class ClientAsyncReader final : public ClientAsyncStreamingInterface,
-                                public AsyncReaderInterface<R> {
+class ClientAsyncReader GRPC_FINAL : public ClientAsyncStreamingInterface,
+                                     public AsyncReaderInterface<R> {
  public:
   // Create a stream and write the first request out.
   ClientAsyncReader(ChannelInterface* channel, CompletionQueue* cq,
@@ -395,7 +395,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&init_buf_);
   }
 
-  void ReadInitialMetadata(void* tag) override {
+  void ReadInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!context_->initial_metadata_received_);
 
     meta_buf_.Reset(tag);
@@ -403,7 +403,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  void Read(R* msg, void* tag) override {
+  void Read(R* msg, void* tag) GRPC_OVERRIDE {
     read_buf_.Reset(tag);
     if (!context_->initial_metadata_received_) {
       read_buf_.AddRecvInitialMetadata(context_);
@@ -412,7 +412,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&read_buf_);
   }
 
-  void Finish(Status* status, void* tag) override {
+  void Finish(Status* status, void* tag) GRPC_OVERRIDE {
     finish_buf_.Reset(tag);
     if (!context_->initial_metadata_received_) {
       finish_buf_.AddRecvInitialMetadata(context_);
@@ -422,7 +422,7 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface,
   }
 
  private:
-  ClientContext* context_ = nullptr;
+  ClientContext* context_;
   Call call_;
   CallOpBuffer init_buf_;
   CallOpBuffer meta_buf_;
@@ -431,8 +431,8 @@ class ClientAsyncReader final : public ClientAsyncStreamingInterface,
 };
 
 template <class W>
-class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
-                                public AsyncWriterInterface<W> {
+class ClientAsyncWriter GRPC_FINAL : public ClientAsyncStreamingInterface,
+                                     public AsyncWriterInterface<W> {
  public:
   ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq,
                     const RpcMethod& method, ClientContext* context,
@@ -445,7 +445,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&init_buf_);
   }
 
-  void ReadInitialMetadata(void* tag) override {
+  void ReadInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!context_->initial_metadata_received_);
 
     meta_buf_.Reset(tag);
@@ -453,7 +453,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  void Write(const W& msg, void* tag) override {
+  void Write(const W& msg, void* tag) GRPC_OVERRIDE {
     write_buf_.Reset(tag);
     write_buf_.AddSendMessage(msg);
     call_.PerformOps(&write_buf_);
@@ -465,7 +465,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&writes_done_buf_);
   }
 
-  void Finish(Status* status, void* tag) override {
+  void Finish(Status* status, void* tag) GRPC_OVERRIDE {
     finish_buf_.Reset(tag);
     if (!context_->initial_metadata_received_) {
       finish_buf_.AddRecvInitialMetadata(context_);
@@ -476,7 +476,7 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
   }
 
  private:
-  ClientContext* context_ = nullptr;
+  ClientContext* context_;
   google::protobuf::Message* const response_;
   Call call_;
   CallOpBuffer init_buf_;
@@ -488,9 +488,9 @@ class ClientAsyncWriter final : public ClientAsyncStreamingInterface,
 
 // Client-side interface for bi-directional streaming.
 template <class W, class R>
-class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
-                                      public AsyncWriterInterface<W>,
-                                      public AsyncReaderInterface<R> {
+class ClientAsyncReaderWriter GRPC_FINAL : public ClientAsyncStreamingInterface,
+                                           public AsyncWriterInterface<W>,
+                                           public AsyncReaderInterface<R> {
  public:
   ClientAsyncReaderWriter(ChannelInterface* channel, CompletionQueue* cq,
                           const RpcMethod& method, ClientContext* context,
@@ -501,7 +501,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&init_buf_);
   }
 
-  void ReadInitialMetadata(void* tag) override {
+  void ReadInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!context_->initial_metadata_received_);
 
     meta_buf_.Reset(tag);
@@ -509,7 +509,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  void Read(R* msg, void* tag) override {
+  void Read(R* msg, void* tag) GRPC_OVERRIDE {
     read_buf_.Reset(tag);
     if (!context_->initial_metadata_received_) {
       read_buf_.AddRecvInitialMetadata(context_);
@@ -518,7 +518,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&read_buf_);
   }
 
-  void Write(const W& msg, void* tag) override {
+  void Write(const W& msg, void* tag) GRPC_OVERRIDE {
     write_buf_.Reset(tag);
     write_buf_.AddSendMessage(msg);
     call_.PerformOps(&write_buf_);
@@ -530,7 +530,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
     call_.PerformOps(&writes_done_buf_);
   }
 
-  void Finish(Status* status, void* tag) override {
+  void Finish(Status* status, void* tag) GRPC_OVERRIDE {
     finish_buf_.Reset(tag);
     if (!context_->initial_metadata_received_) {
       finish_buf_.AddRecvInitialMetadata(context_);
@@ -540,7 +540,7 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
   }
 
  private:
-  ClientContext* context_ = nullptr;
+  ClientContext* context_;
   Call call_;
   CallOpBuffer init_buf_;
   CallOpBuffer meta_buf_;
@@ -551,13 +551,13 @@ class ClientAsyncReaderWriter final : public ClientAsyncStreamingInterface,
 };
 
 template <class W, class R>
-class ServerAsyncReader : public ServerAsyncStreamingInterface,
-                          public AsyncReaderInterface<R> {
+class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface,
+                                     public AsyncReaderInterface<R> {
  public:
   explicit ServerAsyncReader(ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
-  void SendInitialMetadata(void* tag) override {
+  void SendInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!ctx_->sent_initial_metadata_);
 
     meta_buf_.Reset(tag);
@@ -566,7 +566,7 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  void Read(R* msg, void* tag) override {
+  void Read(R* msg, void* tag) GRPC_OVERRIDE {
     read_buf_.Reset(tag);
     read_buf_.AddRecvMessage(msg);
     call_.PerformOps(&read_buf_);
@@ -598,7 +598,7 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface,
   }
 
  private:
-  void BindCall(Call* call) override { call_ = *call; }
+  void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; }
 
   Call call_;
   ServerContext* ctx_;
@@ -608,13 +608,13 @@ class ServerAsyncReader : public ServerAsyncStreamingInterface,
 };
 
 template <class W>
-class ServerAsyncWriter : public ServerAsyncStreamingInterface,
-                          public AsyncWriterInterface<W> {
+class ServerAsyncWriter GRPC_FINAL : public ServerAsyncStreamingInterface,
+                                     public AsyncWriterInterface<W> {
  public:
   explicit ServerAsyncWriter(ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
-  void SendInitialMetadata(void* tag) override {
+  void SendInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!ctx_->sent_initial_metadata_);
 
     meta_buf_.Reset(tag);
@@ -623,7 +623,7 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  void Write(const W& msg, void* tag) override {
+  void Write(const W& msg, void* tag) GRPC_OVERRIDE {
     write_buf_.Reset(tag);
     if (!ctx_->sent_initial_metadata_) {
       write_buf_.AddSendInitialMetadata(&ctx_->initial_metadata_);
@@ -644,7 +644,7 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface,
   }
 
  private:
-  void BindCall(Call* call) override { call_ = *call; }
+  void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; }
 
   Call call_;
   ServerContext* ctx_;
@@ -655,14 +655,14 @@ class ServerAsyncWriter : public ServerAsyncStreamingInterface,
 
 // Server-side interface for bi-directional streaming.
 template <class W, class R>
-class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface,
-                                public AsyncWriterInterface<W>,
-                                public AsyncReaderInterface<R> {
+class ServerAsyncReaderWriter GRPC_FINAL : public ServerAsyncStreamingInterface,
+                                           public AsyncWriterInterface<W>,
+                                           public AsyncReaderInterface<R> {
  public:
   explicit ServerAsyncReaderWriter(ServerContext* ctx)
       : call_(nullptr, nullptr, nullptr), ctx_(ctx) {}
 
-  void SendInitialMetadata(void* tag) override {
+  void SendInitialMetadata(void* tag) GRPC_OVERRIDE {
     GPR_ASSERT(!ctx_->sent_initial_metadata_);
 
     meta_buf_.Reset(tag);
@@ -671,13 +671,13 @@ class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface,
     call_.PerformOps(&meta_buf_);
   }
 
-  virtual void Read(R* msg, void* tag) override {
+  virtual void Read(R* msg, void* tag) GRPC_OVERRIDE {
     read_buf_.Reset(tag);
     read_buf_.AddRecvMessage(msg);
     call_.PerformOps(&read_buf_);
   }
 
-  virtual void Write(const W& msg, void* tag) override {
+  virtual void Write(const W& msg, void* tag) GRPC_OVERRIDE {
     write_buf_.Reset(tag);
     if (!ctx_->sent_initial_metadata_) {
       write_buf_.AddSendInitialMetadata(&ctx_->initial_metadata_);
@@ -698,7 +698,7 @@ class ServerAsyncReaderWriter : public ServerAsyncStreamingInterface,
   }
 
  private:
-  void BindCall(Call* call) override { call_ = *call; }
+  void BindCall(Call* call) GRPC_OVERRIDE { call_ = *call; }
 
   Call call_;
   ServerContext* ctx_;

src/compiler/cpp_generator.cc

@@ -300,13 +300,13 @@ void PrintHeaderService(google::protobuf::io::Printer *printer,
   (*vars)["Service"] = service->name();
 
   printer->Print(*vars,
-                 "class $Service$ final {\n"
+                 "class $Service$ GRPC_FINAL {\n"
                  " public:\n");
   printer->Indent();
 
   // Client side
   printer->Print(
-      "class Stub final : public ::grpc::InternalStub {\n"
+      "class Stub GRPC_FINAL : public ::grpc::InternalStub {\n"
       " public:\n");
   printer->Indent();
   for (int i = 0; i < service->method_count(); ++i) {
@@ -331,7 +331,7 @@ void PrintHeaderService(google::protobuf::io::Printer *printer,
   for (int i = 0; i < service->method_count(); ++i) {
     PrintHeaderServerMethodSync(printer, service->method(i), vars);
   }
-  printer->Print("::grpc::RpcService* service() override final;\n");
+  printer->Print("::grpc::RpcService* service() GRPC_OVERRIDE GRPC_FINAL;\n");
   printer->Outdent();
   printer->Print(
       " private:\n"
@@ -340,7 +340,7 @@ void PrintHeaderService(google::protobuf::io::Printer *printer,
 
   // Server side - Asynchronous
   printer->Print(
-      "class AsyncService final : public ::grpc::AsynchronousService {\n"
+      "class AsyncService GRPC_FINAL : public ::grpc::AsynchronousService {\n"
       " public:\n");
   printer->Indent();
   (*vars)["MethodCount"] = as_string(service->method_count());

src/compiler/python_generator.cc

@@ -216,7 +216,8 @@ bool GetModuleAndMessagePath(const Descriptor* type,
        path_iter != message_path.rend(); ++path_iter) {
     message_type += (*path_iter)->name() + ".";
   }
-  message_type.pop_back();
+  // no pop_back prior to C++11
+  message_type.resize(message_type.size() - 1);
   *out = make_pair(module, message_type);
   return true;
 }

src/compiler/python_plugin.cc

@@ -56,12 +56,10 @@ using std::strlen;
 class PythonGrpcGenerator : public CodeGenerator {
  public:
   PythonGrpcGenerator() {}
-  ~PythonGrpcGenerator() override {}
+  ~PythonGrpcGenerator() {}
 
-  bool Generate(const FileDescriptor* file,
-                const string& parameter,
-                GeneratorContext* context,
-                string* error) const override {
+  bool Generate(const FileDescriptor* file, const string& parameter,
+                GeneratorContext* context, string* error) const {
     // Get output file name.
     string file_name;
     static const int proto_suffix_length = strlen(".proto");

src/compiler/ruby_plugin.cc

@@ -50,12 +50,12 @@
 class RubyGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
  public:
   RubyGrpcGenerator() {}
-  ~RubyGrpcGenerator() override {}
+  ~RubyGrpcGenerator() {}
 
   bool Generate(const google::protobuf::FileDescriptor *file,
                 const std::string &parameter,
                 google::protobuf::compiler::GeneratorContext *context,
-                std::string *error) const override {
+                std::string *error) const {
     std::string code = grpc_ruby_generator::GetServices(file);
     if (code.size() == 0) {
       return true;  // don't generate a file if there are no services

src/cpp/client/channel.h

@@ -49,17 +49,17 @@ class CompletionQueue;
 class Credentials;
 class StreamContextInterface;
 
-class Channel final : public ChannelInterface {
+class Channel GRPC_FINAL : public ChannelInterface {
  public:
   Channel(const grpc::string &target, const ChannelArguments &args);
   Channel(const grpc::string &target, const std::unique_ptr<Credentials> &creds,
           const ChannelArguments &args);
 
-  ~Channel() override;
+  ~Channel() GRPC_OVERRIDE;
 
   virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
-                          CompletionQueue *cq) override;
-  virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) override;
+                          CompletionQueue *cq) GRPC_OVERRIDE;
+  virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) GRPC_OVERRIDE;
 
  private:
   const grpc::string target_;

src/cpp/client/client_context.cc

@@ -41,7 +41,10 @@ using std::chrono::system_clock;
 namespace grpc {
 
 ClientContext::ClientContext()
-    : call_(nullptr), cq_(nullptr), absolute_deadline_(gpr_inf_future) {}
+    : initial_metadata_received_(false),
+      call_(nullptr),
+      cq_(nullptr),
+      absolute_deadline_(gpr_inf_future) {}
 
 ClientContext::~ClientContext() {
   if (call_) {

src/cpp/common/call.cc

@@ -41,6 +41,30 @@
 
 namespace grpc {
 
+CallOpBuffer::CallOpBuffer()
+    : return_tag_(this),
+      send_initial_metadata_(false),
+      initial_metadata_count_(0),
+      initial_metadata_(nullptr),
+      recv_initial_metadata_(nullptr),
+      recv_initial_metadata_arr_{0, 0, nullptr},
+      send_message_(nullptr),
+      send_message_buf_(nullptr),
+      recv_message_(nullptr),
+      recv_message_buf_(nullptr),
+      client_send_close_(false),
+      recv_trailing_metadata_(nullptr),
+      recv_status_(nullptr),
+      recv_trailing_metadata_arr_{0, 0, nullptr},
+      status_code_(GRPC_STATUS_OK),
+      status_details_(nullptr),
+      status_details_capacity_(0),
+      send_status_(nullptr),
+      trailing_metadata_count_(0),
+      trailing_metadata_(nullptr),
+      cancelled_buf_(0),
+      recv_closed_(nullptr) {}
+
 void CallOpBuffer::Reset(void* next_return_tag) {
   return_tag_ = next_return_tag;
 

src/cpp/server/server.cc

@@ -49,11 +49,12 @@
 
 namespace grpc {
 
-class Server::SyncRequest final : public CompletionQueueTag {
+class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
  public:
   SyncRequest(RpcServiceMethod* method, void* tag)
       : method_(method),
         tag_(tag),
+        in_flight_(false),
         has_request_payload_(method->method_type() == RpcMethod::NORMAL_RPC ||
                              method->method_type() ==
                                  RpcMethod::SERVER_STREAMING),
@@ -85,14 +86,14 @@ class Server::SyncRequest final : public CompletionQueueTag {
                    this));
   }
 
-  bool FinalizeResult(void** tag, bool* status) override {
+  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
     if (!*status) {
       grpc_completion_queue_destroy(cq_);
     }
     return true;
   }
 
-  class CallData final {
+  class CallData GRPC_FINAL {
    public:
     explicit CallData(Server* server, SyncRequest* mrd)
         : cq_(mrd->cq_),
@@ -159,7 +160,7 @@ class Server::SyncRequest final : public CompletionQueueTag {
  private:
   RpcServiceMethod* const method_;
   void* const tag_;
-  bool in_flight_ = false;
+  bool in_flight_;
   const bool has_request_payload_;
   const bool has_response_payload_;
   grpc_call* call_;
@@ -294,7 +295,7 @@ void Server::PerformOpsOnCall(CallOpBuffer* buf, Call* call) {
              grpc_call_start_batch(call->call(), ops, nops, buf));
 }
 
-class Server::AsyncRequest final : public CompletionQueueTag {
+class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
  public:
   AsyncRequest(Server* server, void* registered_method, ServerContext* ctx,
                ::google::protobuf::Message* request,
@@ -305,7 +306,9 @@ class Server::AsyncRequest final : public CompletionQueueTag {
         stream_(stream),
         cq_(cq),
         ctx_(ctx),
-        server_(server) {
+        server_(server),
+        call_(nullptr),
+        payload_(nullptr) {
     memset(&array_, 0, sizeof(array_));
     grpc_server_request_registered_call(
         server->server_, registered_method, &call_, &deadline_, &array_,
@@ -319,7 +322,7 @@ class Server::AsyncRequest final : public CompletionQueueTag {
     grpc_metadata_array_destroy(&array_);
   }
 
-  bool FinalizeResult(void** tag, bool* status) override {
+  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE {
     *tag = tag_;
     if (*status && request_) {
       if (payload_) {
@@ -354,10 +357,10 @@ class Server::AsyncRequest final : public CompletionQueueTag {
   CompletionQueue* const cq_;
   ServerContext* const ctx_;
   Server* const server_;
-  grpc_call* call_ = nullptr;
+  grpc_call* call_;
   gpr_timespec deadline_;
   grpc_metadata_array array_;
-  grpc_byte_buffer* payload_ = nullptr;
+  grpc_byte_buffer* payload_;
 };
 
 void Server::RequestAsyncCall(void* registered_method, ServerContext* context,

src/cpp/server/server_builder.cc

@@ -41,7 +41,7 @@
 
 namespace grpc {
 
-ServerBuilder::ServerBuilder() {}
+ServerBuilder::ServerBuilder() : thread_pool_(nullptr) {}
 
 void ServerBuilder::RegisterService(SynchronousService* service) {
   services_.push_back(service->service());

src/cpp/server/server_context.cc

@@ -44,10 +44,13 @@ namespace grpc {
 
 // CompletionOp
 
-class ServerContext::CompletionOp final : public CallOpBuffer {
+class ServerContext::CompletionOp GRPC_FINAL : public CallOpBuffer {
  public:
-  CompletionOp();
-  bool FinalizeResult(void** tag, bool* status) override;
+  // initial refs: one in the server context, one in the cq
+  CompletionOp() : refs_(2), finalized_(false), cancelled_(false) {
+    AddServerRecvClose(&cancelled_);
+  }
+  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE;
 
   bool CheckCancelled(CompletionQueue* cq);
 
@@ -55,13 +58,11 @@ class ServerContext::CompletionOp final : public CallOpBuffer {
 
  private:
   std::mutex mu_;
-  int refs_ = 2;  // initial refs: one in the server context, one in the cq
-  bool finalized_ = false;
-  bool cancelled_ = false;
+  int refs_;
+  bool finalized_;
+  bool cancelled_;
 };
 
-ServerContext::CompletionOp::CompletionOp() { AddServerRecvClose(&cancelled_); }
-
 void ServerContext::CompletionOp::Unref() {
   std::unique_lock<std::mutex> lock(mu_);
   if (--refs_ == 0) {
@@ -90,11 +91,19 @@ bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) {
 
 // ServerContext body
 
-ServerContext::ServerContext() {}
+ServerContext::ServerContext()
+    : completion_op_(nullptr),
+      call_(nullptr),
+      cq_(nullptr),
+      sent_initial_metadata_(false) {}
 
 ServerContext::ServerContext(gpr_timespec deadline, grpc_metadata* metadata,
                              size_t metadata_count)
-    : deadline_(Timespec2Timepoint(deadline)) {
+    : completion_op_(nullptr),
+      deadline_(Timespec2Timepoint(deadline)),
+      call_(nullptr),
+      cq_(nullptr),
+      sent_initial_metadata_(false) {
   for (size_t i = 0; i < metadata_count; i++) {
     client_metadata_.insert(std::make_pair(
         grpc::string(metadata[i].key),

src/cpp/server/thread_pool.cc

@@ -35,7 +35,7 @@
 
 namespace grpc {
 
-ThreadPool::ThreadPool(int num_threads) {
+ThreadPool::ThreadPool(int num_threads) : shutdown_(false) {
   for (int i = 0; i < num_threads; i++) {
     threads_.push_back(std::thread([this]() {
       for (;;) {

src/cpp/server/thread_pool.h

@@ -34,6 +34,7 @@
 #ifndef __GRPCPP_INTERNAL_SERVER_THREAD_POOL_H__
 #define __GRPCPP_INTERNAL_SERVER_THREAD_POOL_H__
 
+#include <grpc++/config.h>
 #include <grpc++/thread_pool_interface.h>
 
 #include <condition_variable>
@@ -44,17 +45,17 @@
 
 namespace grpc {
 
-class ThreadPool final : public ThreadPoolInterface {
+class ThreadPool GRPC_FINAL : public ThreadPoolInterface {
  public:
   explicit ThreadPool(int num_threads);
   ~ThreadPool();
 
-  void ScheduleCallback(const std::function<void()> &callback) override;
+  void ScheduleCallback(const std::function<void()> &callback) GRPC_OVERRIDE;
 
  private:
   std::mutex mu_;
   std::condition_variable cv_;
-  bool shutdown_ = false;
+  bool shutdown_;
   std::queue<std::function<void()>> callbacks_;
   std::vector<std::thread> threads_;
 };

templates/Makefile.template

@@ -169,6 +169,10 @@ $(error Invalid CONFIG value '$(CONFIG)')
 endif
 
 
+# Detect if we can use C++11
+CXX11_CHECK_CMD = $(CXX) -std=c++11 -o /dev/null -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.
 # In most cases, you won't have to change anything, but if you are
 # cross-compiling, you can override these variables from GNU make's
@@ -184,7 +188,12 @@ DEFINES += $(DEFINES_$(CONFIG)) INSTALL_PREFIX=\"$(prefix)\"
 LDFLAGS += $(LDFLAGS_$(CONFIG))
 
 CFLAGS += -std=c89 -pedantic
+ifeq ($(HAS_CXX11),true)
 CXXFLAGS += -std=c++11
+else
+CXXFLAGS += -std=c++0x
+DEFINES += GRPC_OLD_CXX
+endif
 CPPFLAGS += -g -fPIC -Wall -Wextra -Werror -Wno-long-long -Wno-unused-parameter
 LDFLAGS += -g -fPIC
 
@@ -495,7 +504,11 @@ third_party/protobuf/configure:
 
 $(LIBDIR)/$(CONFIG)/protobuf/libprotobuf.a: third_party/protobuf/configure
 	$(E) "[MAKE]    Building protobuf"
+ifeq ($(HAVE_CXX11),true)
 	$(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-DLANG_CXX11 -std=c++11" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static)
+else
+	$(Q)(cd third_party/protobuf ; CC="$(CC)" CXX="$(CXX)" LDFLAGS="$(LDFLAGS_$(CONFIG)) -g" CXXFLAGS="-std=c++0x" CPPFLAGS="-fPIC $(CPPFLAGS_$(CONFIG)) -g" ./configure --disable-shared --enable-static)
+endif
 	$(Q)$(MAKE) -C third_party/protobuf clean
 	$(Q)$(MAKE) -C third_party/protobuf
 	$(Q)mkdir -p $(LIBDIR)/$(CONFIG)/protobuf

test/build/c++11.cc

@@ -0,0 +1,52 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+/* This is just a compilation test, to see if we have zlib installed. */
+
+#include <stdlib.h>
+#include <zlib.h>
+
+class Base {
+ public:
+  virtual void foo() = 0;
+};
+
+class Foo final : public Base {
+ public:
+  void foo() override {}
+};
+
+int main() {
+  Foo().foo();
+  return 0;
+}

test/cpp/end2end/async_end2end_test.cc

@@ -81,7 +81,7 @@ class AsyncEnd2endTest : public ::testing::Test {
  protected:
   AsyncEnd2endTest() : service_(&srv_cq_) {}
 
-  void SetUp() override {
+  void SetUp() GRPC_OVERRIDE {
     int port = grpc_pick_unused_port_or_die();
     server_address_ << "localhost:" << port;
     // Setup server
@@ -91,7 +91,7 @@ class AsyncEnd2endTest : public ::testing::Test {
     server_ = builder.BuildAndStart();
   }
 
-  void TearDown() override {
+  void TearDown() GRPC_OVERRIDE {
     server_->Shutdown();
     void* ignored_tag;
     bool ignored_ok;

test/cpp/end2end/end2end_test.cc

@@ -83,7 +83,7 @@ void MaybeEchoDeadline(ServerContext* context, const EchoRequest* request,
 class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
  public:
   Status Echo(ServerContext* context, const EchoRequest* request,
-              EchoResponse* response) override {
+              EchoResponse* response) GRPC_OVERRIDE {
     response->set_message(request->message());
     MaybeEchoDeadline(context, request, response);
     return Status::OK;
@@ -93,7 +93,7 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
 
   Status RequestStream(ServerContext* context,
                        ServerReader<EchoRequest>* reader,
-                       EchoResponse* response) override {
+                       EchoResponse* response) GRPC_OVERRIDE {
     EchoRequest request;
     response->set_message("");
     while (reader->Read(&request)) {
@@ -105,7 +105,7 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
   // Return 3 messages.
   // TODO(yangg) make it generic by adding a parameter into EchoRequest
   Status ResponseStream(ServerContext* context, const EchoRequest* request,
-                        ServerWriter<EchoResponse>* writer) override {
+                        ServerWriter<EchoResponse>* writer) GRPC_OVERRIDE {
     EchoResponse response;
     response.set_message(request->message() + "0");
     writer->Write(response);
@@ -117,9 +117,9 @@ class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
     return Status::OK;
   }
 
-  Status BidiStream(
-      ServerContext* context,
-      ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
+  Status BidiStream(ServerContext* context,
+                    ServerReaderWriter<EchoResponse, EchoRequest>* stream)
+      GRPC_OVERRIDE {
     EchoRequest request;
     EchoResponse response;
     while (stream->Read(&request)) {
@@ -135,7 +135,7 @@ class TestServiceImplDupPkg
     : public ::grpc::cpp::test::util::duplicate::TestService::Service {
  public:
   Status Echo(ServerContext* context, const EchoRequest* request,
-              EchoResponse* response) override {
+              EchoResponse* response) GRPC_OVERRIDE {
     response->set_message("no package");
     return Status::OK;
   }
@@ -145,7 +145,7 @@ class End2endTest : public ::testing::Test {
  protected:
   End2endTest() : thread_pool_(2) {}
 
-  void SetUp() override {
+  void SetUp() GRPC_OVERRIDE {
     int port = grpc_pick_unused_port_or_die();
     server_address_ << "localhost:" << port;
     // Setup server
@@ -157,7 +157,7 @@ class End2endTest : public ::testing::Test {
     server_ = builder.BuildAndStart();
   }
 
-  void TearDown() override { server_->Shutdown(); }
+  void TearDown() GRPC_OVERRIDE { server_->Shutdown(); }
 
   void ResetStub() {
     std::shared_ptr<ChannelInterface> channel =

test/cpp/interop/client.cc

@@ -38,6 +38,8 @@
 #include <string>
 #include <thread>
 
+#include <unistd.h>
+
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <gflags/gflags.h>
@@ -313,8 +315,7 @@ void DoResponseStreamingWithSlowConsumer() {
     GPR_ASSERT(response.payload().body() ==
                grpc::string(kResponseMessageSize, '\0'));
     gpr_log(GPR_INFO, "received message %d", i);
-    std::this_thread::sleep_for(
-        std::chrono::milliseconds(kReceiveDelayMilliSeconds));
+    usleep(kReceiveDelayMilliSeconds * 1000);
     ++i;
   }
   GPR_ASSERT(kNumResponseMessages == i);

test/cpp/interop/server.cc

@@ -36,6 +36,7 @@
 #include <thread>
 
 #include <signal.h>
+#include <unistd.h>
 
 #include <gflags/gflags.h>
 #include <grpc/grpc.h>
@@ -222,7 +223,7 @@ void RunServer() {
   std::unique_ptr<Server> server(builder.BuildAndStart());
   gpr_log(GPR_INFO, "Server listening on %s", server_address.str().c_str());
   while (!got_sigint) {
-    std::this_thread::sleep_for(std::chrono::seconds(5));
+    sleep(5);
   }
 }
 

test/cpp/qps/server.cc

@@ -36,6 +36,8 @@
 #include <sys/signal.h>
 #include <thread>
 
+#include <unistd.h>
+
 #include <gflags/gflags.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/host_port.h>
@@ -97,7 +99,7 @@ static bool SetPayload(PayloadType type, int size, Payload* payload) {
 
 namespace {
 
-class TestServiceImpl final : public TestService::Service {
+class TestServiceImpl GRPC_FINAL : public TestService::Service {
  public:
   Status CollectServerStats(ServerContext* context, const StatsRequest*,
                             ServerStats* response) {
@@ -146,7 +148,7 @@ static void RunServer() {
   grpc_profiler_start("qps_server.prof");
 
   while (!got_sigint) {
-    std::this_thread::sleep_for(std::chrono::seconds(5));
+    sleep(5);
   }
 
   grpc_profiler_stop();

tools/run_tests/jobset.py

@@ -292,7 +292,7 @@ def run(cmdlines,
   if not travis:
     cmdlines = shuffle_iteratable(cmdlines)
   else:
-    cmdlines = sorted(cmdlines)
+    cmdlines = sorted(cmdlines, key=lambda x: x.shortname)
   for cmdline in cmdlines:
     if not js.start(cmdline):
       break