Merge pull request #18715 from grpc/revert-18198-revert-18076-revert-17797-channel

Revert "Revert "Revert "Folding the Channel class into the grpc_impl namespace."""
pull/18717/head
Karthik Ravi Shankar 6 years ago committed by GitHub
commit e8b2bced4d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
  1. 1
      BUILD
  2. 1
      BUILD.gn
  3. 3
      CMakeLists.txt
  4. 3
      Makefile
  5. 1
      build.yaml
  6. 1
      gRPC-C++.podspec
  7. 88
      include/grpcpp/channel.h
  8. 116
      include/grpcpp/channel_impl.h
  9. 5
      include/grpcpp/impl/codegen/client_callback.h
  10. 13
      include/grpcpp/impl/codegen/client_context.h
  11. 6
      include/grpcpp/impl/codegen/client_interceptor.h
  12. 4
      include/grpcpp/impl/codegen/completion_queue.h
  13. 5
      include/grpcpp/impl/codegen/server_interface.h
  14. 19
      include/grpcpp/security/credentials.h
  15. 1
      include/grpcpp/server_impl.h
  16. 4
      src/compiler/cpp_generator.cc
  17. 62
      src/cpp/client/channel_cc.cc
  18. 9
      src/cpp/client/client_context.cc
  19. 4
      src/cpp/client/create_channel.cc
  20. 9
      src/cpp/client/create_channel_internal.cc
  21. 9
      src/cpp/client/create_channel_internal.h
  22. 6
      src/cpp/client/create_channel_posix.cc
  23. 2
      src/cpp/client/cronet_credentials.cc
  24. 2
      src/cpp/client/insecure_credentials.cc
  25. 2
      src/cpp/client/secure_credentials.cc
  26. 9
      src/cpp/client/secure_credentials.h
  27. 4
      src/cpp/server/server_cc.cc
  28. 5
      test/cpp/codegen/compiler_test_golden
  29. 2
      test/cpp/codegen/golden_file_test.cc
  30. 2
      test/cpp/microbenchmarks/bm_call_create.cc
  31. 2
      test/cpp/microbenchmarks/fullstack_fixtures.h
  32. 2
      test/cpp/performance/writes_per_rpc_test.cc
  33. 26
      test/cpp/util/create_test_channel.h
  34. 1
      tools/doxygen/Doxyfile.c++
  35. 1
      tools/doxygen/Doxyfile.c++.internal
  36. 2
      tools/run_tests/generated/sources_and_headers.json

@ -216,7 +216,6 @@ GRPCXX_PUBLIC_HDRS = [
"include/grpcpp/alarm.h", "include/grpcpp/alarm.h",
"include/grpcpp/alarm_impl.h", "include/grpcpp/alarm_impl.h",
"include/grpcpp/channel.h", "include/grpcpp/channel.h",
"include/grpcpp/channel_impl.h",
"include/grpcpp/client_context.h", "include/grpcpp/client_context.h",
"include/grpcpp/completion_queue.h", "include/grpcpp/completion_queue.h",
"include/grpcpp/create_channel.h", "include/grpcpp/create_channel.h",

@ -1003,7 +1003,6 @@ config("grpc_config") {
"include/grpcpp/alarm.h", "include/grpcpp/alarm.h",
"include/grpcpp/alarm_impl.h", "include/grpcpp/alarm_impl.h",
"include/grpcpp/channel.h", "include/grpcpp/channel.h",
"include/grpcpp/channel_impl.h",
"include/grpcpp/client_context.h", "include/grpcpp/client_context.h",
"include/grpcpp/completion_queue.h", "include/grpcpp/completion_queue.h",
"include/grpcpp/create_channel.h", "include/grpcpp/create_channel.h",

@ -2998,7 +2998,6 @@ foreach(_hdr
include/grpcpp/alarm.h include/grpcpp/alarm.h
include/grpcpp/alarm_impl.h include/grpcpp/alarm_impl.h
include/grpcpp/channel.h include/grpcpp/channel.h
include/grpcpp/channel_impl.h
include/grpcpp/client_context.h include/grpcpp/client_context.h
include/grpcpp/completion_queue.h include/grpcpp/completion_queue.h
include/grpcpp/create_channel.h include/grpcpp/create_channel.h
@ -3603,7 +3602,6 @@ foreach(_hdr
include/grpcpp/alarm.h include/grpcpp/alarm.h
include/grpcpp/alarm_impl.h include/grpcpp/alarm_impl.h
include/grpcpp/channel.h include/grpcpp/channel.h
include/grpcpp/channel_impl.h
include/grpcpp/client_context.h include/grpcpp/client_context.h
include/grpcpp/completion_queue.h include/grpcpp/completion_queue.h
include/grpcpp/create_channel.h include/grpcpp/create_channel.h
@ -4584,7 +4582,6 @@ foreach(_hdr
include/grpcpp/alarm.h include/grpcpp/alarm.h
include/grpcpp/alarm_impl.h include/grpcpp/alarm_impl.h
include/grpcpp/channel.h include/grpcpp/channel.h
include/grpcpp/channel_impl.h
include/grpcpp/client_context.h include/grpcpp/client_context.h
include/grpcpp/completion_queue.h include/grpcpp/completion_queue.h
include/grpcpp/create_channel.h include/grpcpp/create_channel.h

@ -5333,7 +5333,6 @@ PUBLIC_HEADERS_CXX += \
include/grpcpp/alarm.h \ include/grpcpp/alarm.h \
include/grpcpp/alarm_impl.h \ include/grpcpp/alarm_impl.h \
include/grpcpp/channel.h \ include/grpcpp/channel.h \
include/grpcpp/channel_impl.h \
include/grpcpp/client_context.h \ include/grpcpp/client_context.h \
include/grpcpp/completion_queue.h \ include/grpcpp/completion_queue.h \
include/grpcpp/create_channel.h \ include/grpcpp/create_channel.h \
@ -5946,7 +5945,6 @@ PUBLIC_HEADERS_CXX += \
include/grpcpp/alarm.h \ include/grpcpp/alarm.h \
include/grpcpp/alarm_impl.h \ include/grpcpp/alarm_impl.h \
include/grpcpp/channel.h \ include/grpcpp/channel.h \
include/grpcpp/channel_impl.h \
include/grpcpp/client_context.h \ include/grpcpp/client_context.h \
include/grpcpp/completion_queue.h \ include/grpcpp/completion_queue.h \
include/grpcpp/create_channel.h \ include/grpcpp/create_channel.h \
@ -6876,7 +6874,6 @@ PUBLIC_HEADERS_CXX += \
include/grpcpp/alarm.h \ include/grpcpp/alarm.h \
include/grpcpp/alarm_impl.h \ include/grpcpp/alarm_impl.h \
include/grpcpp/channel.h \ include/grpcpp/channel.h \
include/grpcpp/channel_impl.h \
include/grpcpp/client_context.h \ include/grpcpp/client_context.h \
include/grpcpp/completion_queue.h \ include/grpcpp/completion_queue.h \
include/grpcpp/create_channel.h \ include/grpcpp/create_channel.h \

@ -1344,7 +1344,6 @@ filegroups:
- include/grpcpp/alarm.h - include/grpcpp/alarm.h
- include/grpcpp/alarm_impl.h - include/grpcpp/alarm_impl.h
- include/grpcpp/channel.h - include/grpcpp/channel.h
- include/grpcpp/channel_impl.h
- include/grpcpp/client_context.h - include/grpcpp/client_context.h
- include/grpcpp/completion_queue.h - include/grpcpp/completion_queue.h
- include/grpcpp/create_channel.h - include/grpcpp/create_channel.h

@ -82,7 +82,6 @@ Pod::Spec.new do |s|
ss.source_files = 'include/grpcpp/alarm.h', ss.source_files = 'include/grpcpp/alarm.h',
'include/grpcpp/alarm_impl.h', 'include/grpcpp/alarm_impl.h',
'include/grpcpp/channel.h', 'include/grpcpp/channel.h',
'include/grpcpp/channel_impl.h',
'include/grpcpp/client_context.h', 'include/grpcpp/client_context.h',
'include/grpcpp/completion_queue.h', 'include/grpcpp/completion_queue.h',
'include/grpcpp/create_channel.h', 'include/grpcpp/create_channel.h',

@ -19,15 +19,97 @@
#ifndef GRPCPP_CHANNEL_H #ifndef GRPCPP_CHANNEL_H
#define GRPCPP_CHANNEL_H #define GRPCPP_CHANNEL_H
#include <grpcpp/channel_impl.h> #include <memory>
#include <mutex>
namespace grpc { #include <grpc/grpc.h>
#include <grpcpp/impl/call.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/codegen/client_interceptor.h>
#include <grpcpp/impl/codegen/config.h>
#include <grpcpp/impl/codegen/grpc_library.h>
#include <grpcpp/impl/codegen/sync.h>
struct grpc_channel;
typedef ::grpc_impl::Channel Channel; namespace grpc {
namespace experimental { namespace experimental {
/// Resets the channel's connection backoff.
/// TODO(roth): Once we see whether this proves useful, either create a gRFC
/// and change this to be a method of the Channel class, or remove it.
void ChannelResetConnectionBackoff(Channel* channel); void ChannelResetConnectionBackoff(Channel* channel);
} // namespace experimental } // namespace experimental
/// Channels represent a connection to an endpoint. Created by \a CreateChannel.
class Channel final : public ChannelInterface,
public internal::CallHook,
public std::enable_shared_from_this<Channel>,
private GrpcLibraryCodegen {
public:
~Channel();
/// Get the current channel state. If the channel is in IDLE and
/// \a try_to_connect is set to true, try to connect.
grpc_connectivity_state GetState(bool try_to_connect) override;
/// Returns the LB policy name, or the empty string if not yet available.
grpc::string GetLoadBalancingPolicyName() const;
/// Returns the service config in JSON form, or the empty string if
/// not available.
grpc::string GetServiceConfigJSON() const;
private:
template <class InputMessage, class OutputMessage>
friend class internal::BlockingUnaryCallImpl;
friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
friend std::shared_ptr<Channel> CreateChannelInternal(
const grpc::string& host, grpc_channel* c_channel,
std::vector<
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators);
friend class internal::InterceptedChannel;
Channel(const grpc::string& host, grpc_channel* c_channel,
std::vector<
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators);
internal::Call CreateCall(const internal::RpcMethod& method,
ClientContext* context,
CompletionQueue* cq) override;
void PerformOpsOnCall(internal::CallOpSetInterface* ops,
internal::Call* call) override;
void* RegisterMethod(const char* method) override;
void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline, CompletionQueue* cq,
void* tag) override;
bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline) override;
CompletionQueue* CallbackCQ() override;
internal::Call CreateCallInternal(const internal::RpcMethod& method,
ClientContext* context, CompletionQueue* cq,
size_t interceptor_pos) override;
const grpc::string host_;
grpc_channel* const c_channel_; // owned
// mu_ protects callback_cq_ (the per-channel callbackable completion queue)
grpc::internal::Mutex mu_;
// callback_cq_ references the callbackable completion queue associated
// with this channel (if any). It is set on the first call to CallbackCQ().
// It is _not owned_ by the channel; ownership belongs with its internal
// shutdown callback tag (invoked when the CQ is fully shutdown).
CompletionQueue* callback_cq_ = nullptr;
std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators_;
};
} // namespace grpc } // namespace grpc
#endif // GRPCPP_CHANNEL_H #endif // GRPCPP_CHANNEL_H

@ -1,116 +0,0 @@
/*
*
* Copyright 2015 gRPC authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef GRPCPP_CHANNEL_IMPL_H
#define GRPCPP_CHANNEL_IMPL_H
#include <memory>
#include <mutex>
#include <grpc/grpc.h>
#include <grpcpp/impl/call.h>
#include <grpcpp/impl/codegen/channel_interface.h>
#include <grpcpp/impl/codegen/client_interceptor.h>
#include <grpcpp/impl/codegen/config.h>
#include <grpcpp/impl/codegen/grpc_library.h>
#include <grpcpp/impl/codegen/sync.h>
struct grpc_channel;
namespace grpc_impl {
namespace experimental {
/// Resets the channel's connection backoff.
/// TODO(roth): Once we see whether this proves useful, either create a gRFC
/// and change this to be a method of the Channel class, or remove it.
void ChannelResetConnectionBackoff(Channel* channel);
} // namespace experimental
/// Channels represent a connection to an endpoint. Created by \a CreateChannel.
class Channel final : public ::grpc::ChannelInterface,
public ::grpc::internal::CallHook,
public std::enable_shared_from_this<Channel>,
private ::grpc::GrpcLibraryCodegen {
public:
~Channel();
/// Get the current channel state. If the channel is in IDLE and
/// \a try_to_connect is set to true, try to connect.
grpc_connectivity_state GetState(bool try_to_connect) override;
/// Returns the LB policy name, or the empty string if not yet available.
grpc::string GetLoadBalancingPolicyName() const;
/// Returns the service config in JSON form, or the empty string if
/// not available.
grpc::string GetServiceConfigJSON() const;
private:
template <class InputMessage, class OutputMessage>
friend class ::grpc::internal::BlockingUnaryCallImpl;
friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
friend std::shared_ptr<Channel> CreateChannelInternal(
const grpc::string& host, grpc_channel* c_channel,
std::vector<std::unique_ptr<
::grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators);
friend class ::grpc::internal::InterceptedChannel;
Channel(const grpc::string& host, grpc_channel* c_channel,
std::vector<std::unique_ptr<
::grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators);
::grpc::internal::Call CreateCall(const ::grpc::internal::RpcMethod& method,
::grpc::ClientContext* context,
::grpc::CompletionQueue* cq) override;
void PerformOpsOnCall(::grpc::internal::CallOpSetInterface* ops,
::grpc::internal::Call* call) override;
void* RegisterMethod(const char* method) override;
void NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline,
::grpc::CompletionQueue* cq, void* tag) override;
bool WaitForStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline) override;
::grpc::CompletionQueue* CallbackCQ() override;
::grpc::internal::Call CreateCallInternal(
const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context,
::grpc::CompletionQueue* cq, size_t interceptor_pos) override;
const grpc::string host_;
grpc_channel* const c_channel_; // owned
// mu_ protects callback_cq_ (the per-channel callbackable completion queue)
grpc::internal::Mutex mu_;
// callback_cq_ references the callbackable completion queue associated
// with this channel (if any). It is set on the first call to CallbackCQ().
// It is _not owned_ by the channel; ownership belongs with its internal
// shutdown callback tag (invoked when the CQ is fully shutdown).
::grpc::CompletionQueue* callback_cq_ = nullptr;
std::vector<
std::unique_ptr<::grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators_;
};
} // namespace grpc_impl
#endif // GRPCPP_CHANNEL_IMPL_H

@ -29,12 +29,9 @@
#include <grpcpp/impl/codegen/core_codegen_interface.h> #include <grpcpp/impl/codegen/core_codegen_interface.h>
#include <grpcpp/impl/codegen/status.h> #include <grpcpp/impl/codegen/status.h>
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class Channel;
class ClientContext; class ClientContext;
class CompletionQueue; class CompletionQueue;

@ -57,13 +57,9 @@
struct census_context; struct census_context;
struct grpc_call; struct grpc_call;
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class Channel;
class ChannelInterface; class ChannelInterface;
class CompletionQueue; class CompletionQueue;
class CallCredentials; class CallCredentials;
@ -396,7 +392,7 @@ class ClientContext {
friend class ::grpc::testing::InteropClientContextInspector; friend class ::grpc::testing::InteropClientContextInspector;
friend class ::grpc::internal::CallOpClientRecvStatus; friend class ::grpc::internal::CallOpClientRecvStatus;
friend class ::grpc::internal::CallOpRecvInitialMetadata; friend class ::grpc::internal::CallOpRecvInitialMetadata;
friend class ::grpc_impl::Channel; friend class Channel;
template <class R> template <class R>
friend class ::grpc::ClientReader; friend class ::grpc::ClientReader;
template <class W> template <class W>
@ -428,8 +424,7 @@ class ClientContext {
} }
grpc_call* call() const { return call_; } grpc_call* call() const { return call_; }
void set_call(grpc_call* call, void set_call(grpc_call* call, const std::shared_ptr<Channel>& channel);
const std::shared_ptr<::grpc_impl::Channel>& channel);
experimental::ClientRpcInfo* set_client_rpc_info( experimental::ClientRpcInfo* set_client_rpc_info(
const char* method, internal::RpcMethod::RpcType type, const char* method, internal::RpcMethod::RpcType type,
@ -462,7 +457,7 @@ class ClientContext {
bool wait_for_ready_explicitly_set_; bool wait_for_ready_explicitly_set_;
bool idempotent_; bool idempotent_;
bool cacheable_; bool cacheable_;
std::shared_ptr<::grpc_impl::Channel> channel_; std::shared_ptr<Channel> channel_;
grpc::internal::Mutex mu_; grpc::internal::Mutex mu_;
grpc_call* call_; grpc_call* call_;
bool call_canceled_; bool call_canceled_;

@ -26,14 +26,10 @@
#include <grpcpp/impl/codegen/rpc_method.h> #include <grpcpp/impl/codegen/rpc_method.h>
#include <grpcpp/impl/codegen/string_ref.h> #include <grpcpp/impl/codegen/string_ref.h>
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class ClientContext; class ClientContext;
class Channel;
namespace internal { namespace internal {
class InterceptorBatchMethodsImpl; class InterceptorBatchMethodsImpl;

@ -43,7 +43,6 @@ struct grpc_completion_queue;
namespace grpc_impl { namespace grpc_impl {
class Channel;
class Server; class Server;
class ServerBuilder; class ServerBuilder;
} // namespace grpc_impl } // namespace grpc_impl
@ -64,6 +63,7 @@ template <class W, class R>
class ServerReaderWriterBody; class ServerReaderWriterBody;
} // namespace internal } // namespace internal
class Channel;
class ChannelInterface; class ChannelInterface;
class ClientContext; class ClientContext;
class CompletionQueue; class CompletionQueue;
@ -281,7 +281,7 @@ class CompletionQueue : private GrpcLibraryCodegen {
friend class ::grpc::internal::BlockingUnaryCallImpl; friend class ::grpc::internal::BlockingUnaryCallImpl;
// Friends that need access to constructor for callback CQ // Friends that need access to constructor for callback CQ
friend class ::grpc_impl::Channel; friend class ::grpc::Channel;
// For access to Register/CompleteAvalanching // For access to Register/CompleteAvalanching
template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6> template <class Op1, class Op2, class Op3, class Op4, class Op5, class Op6>

@ -29,12 +29,13 @@
#include <grpcpp/impl/codegen/server_context.h> #include <grpcpp/impl/codegen/server_context.h>
namespace grpc_impl { namespace grpc_impl {
class Channel;
class ServerCredentials; class ServerCredentials;
} // namespace grpc_impl }
namespace grpc { namespace grpc {
class AsyncGenericService; class AsyncGenericService;
class Channel;
class GenericServerContext; class GenericServerContext;
class ServerCompletionQueue; class ServerCompletionQueue;
class ServerContext; class ServerContext;

@ -32,26 +32,20 @@
struct grpc_call; struct grpc_call;
namespace grpc_impl {
class Channel;
} // namespace grpc_impl
namespace grpc { namespace grpc {
class CallCredentials; class CallCredentials;
class ChannelArguments; class ChannelArguments;
class ChannelCredentials; class ChannelCredentials;
class SecureCallCredentials;
class SecureChannelCredentials;
} // namespace grpc } // namespace grpc
namespace grpc_impl { namespace grpc_impl {
std::shared_ptr<Channel> CreateCustomChannel( std::shared_ptr<grpc::Channel> CreateCustomChannel(
const grpc::string& target, const grpc::string& target,
const std::shared_ptr<grpc::ChannelCredentials>& creds, const std::shared_ptr<grpc::ChannelCredentials>& creds,
const grpc::ChannelArguments& args); const grpc::ChannelArguments& args);
namespace experimental { namespace experimental {
std::shared_ptr<Channel> CreateCustomChannelWithInterceptors( std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
const grpc::string& target, const grpc::string& target,
const std::shared_ptr<grpc::ChannelCredentials>& creds, const std::shared_ptr<grpc::ChannelCredentials>& creds,
const grpc::ChannelArguments& args, const grpc::ChannelArguments& args,
@ -61,6 +55,7 @@ std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
} // namespace experimental } // namespace experimental
} // namespace grpc_impl } // namespace grpc_impl
namespace grpc { namespace grpc {
class Channel;
class SecureChannelCredentials; class SecureChannelCredentials;
class SecureCallCredentials; class SecureCallCredentials;
@ -83,12 +78,12 @@ class ChannelCredentials : private GrpcLibraryCodegen {
virtual SecureChannelCredentials* AsSecureCredentials() = 0; virtual SecureChannelCredentials* AsSecureCredentials() = 0;
private: private:
friend std::shared_ptr<::grpc_impl::Channel> grpc_impl::CreateCustomChannel( friend std::shared_ptr<Channel> grpc_impl::CreateCustomChannel(
const grpc::string& target, const grpc::string& target,
const std::shared_ptr<ChannelCredentials>& creds, const std::shared_ptr<ChannelCredentials>& creds,
const grpc::ChannelArguments& args); const grpc::ChannelArguments& args);
friend std::shared_ptr<::grpc_impl::Channel> friend std::shared_ptr<Channel>
grpc_impl::experimental::CreateCustomChannelWithInterceptors( grpc_impl::experimental::CreateCustomChannelWithInterceptors(
const grpc::string& target, const grpc::string& target,
const std::shared_ptr<ChannelCredentials>& creds, const std::shared_ptr<ChannelCredentials>& creds,
@ -97,12 +92,12 @@ class ChannelCredentials : private GrpcLibraryCodegen {
grpc::experimental::ClientInterceptorFactoryInterface>> grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators); interceptor_creators);
virtual std::shared_ptr<::grpc_impl::Channel> CreateChannel( virtual std::shared_ptr<Channel> CreateChannel(
const grpc::string& target, const ChannelArguments& args) = 0; const grpc::string& target, const ChannelArguments& args) = 0;
// This function should have been a pure virtual function, but it is // This function should have been a pure virtual function, but it is
// implemented as a virtual function so that it does not break API. // implemented as a virtual function so that it does not break API.
virtual std::shared_ptr<::grpc_impl::Channel> CreateChannelWithInterceptors( virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
const grpc::string& target, const ChannelArguments& args, const grpc::string& target, const ChannelArguments& args,
std::vector< std::vector<
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>

@ -27,7 +27,6 @@
#include <grpc/compression.h> #include <grpc/compression.h>
#include <grpc/support/atm.h> #include <grpc/support/atm.h>
#include <grpcpp/channel.h>
#include <grpcpp/completion_queue.h> #include <grpcpp/completion_queue.h>
#include <grpcpp/impl/call.h> #include <grpcpp/impl/call.h>
#include <grpcpp/impl/codegen/client_interceptor.h> #include <grpcpp/impl/codegen/client_interceptor.h>

@ -145,11 +145,9 @@ grpc::string GetHeaderIncludes(grpc_generator::File* file,
PrintIncludes(printer.get(), headers, params.use_system_headers, PrintIncludes(printer.get(), headers, params.use_system_headers,
params.grpc_search_path); params.grpc_search_path);
printer->Print(vars, "\n"); printer->Print(vars, "\n");
printer->Print(vars, "namespace grpc_impl {\n");
printer->Print(vars, "class Channel;\n");
printer->Print(vars, "} // namespace grpc_impl\n\n");
printer->Print(vars, "namespace grpc {\n"); printer->Print(vars, "namespace grpc {\n");
printer->Print(vars, "class CompletionQueue;\n"); printer->Print(vars, "class CompletionQueue;\n");
printer->Print(vars, "class Channel;\n");
printer->Print(vars, "class ServerCompletionQueue;\n"); printer->Print(vars, "class ServerCompletionQueue;\n");
printer->Print(vars, "class ServerContext;\n"); printer->Print(vars, "class ServerContext;\n");
printer->Print(vars, "} // namespace grpc\n\n"); printer->Print(vars, "} // namespace grpc\n\n");

@ -42,18 +42,14 @@
#include "src/core/lib/gpr/string.h" #include "src/core/lib/gpr/string.h"
#include "src/core/lib/surface/completion_queue.h" #include "src/core/lib/surface/completion_queue.h"
void grpc::experimental::ChannelResetConnectionBackoff( namespace grpc {
::grpc::Channel* channel) {
grpc_impl::experimental::ChannelResetConnectionBackoff(channel); static internal::GrpcLibraryInitializer g_gli_initializer;
} Channel::Channel(
const grpc::string& host, grpc_channel* channel,
namespace grpc_impl { std::vector<
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
static ::grpc::internal::GrpcLibraryInitializer g_gli_initializer; interceptor_creators)
Channel::Channel(const grpc::string& host, grpc_channel* channel,
std::vector<std::unique_ptr<
::grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators)
: host_(host), c_channel_(channel) { : host_(host), c_channel_(channel) {
interceptor_creators_ = std::move(interceptor_creators); interceptor_creators_ = std::move(interceptor_creators);
g_gli_initializer.summon(); g_gli_initializer.summon();
@ -69,8 +65,7 @@ Channel::~Channel() {
namespace { namespace {
inline grpc_slice SliceFromArray(const char* arr, size_t len) { inline grpc_slice SliceFromArray(const char* arr, size_t len) {
return ::grpc::g_core_codegen_interface->grpc_slice_from_copied_buffer(arr, return g_core_codegen_interface->grpc_slice_from_copied_buffer(arr, len);
len);
} }
grpc::string GetChannelInfoField(grpc_channel* channel, grpc::string GetChannelInfoField(grpc_channel* channel,
@ -108,9 +103,10 @@ void ChannelResetConnectionBackoff(Channel* channel) {
} // namespace experimental } // namespace experimental
::grpc::internal::Call Channel::CreateCallInternal( internal::Call Channel::CreateCallInternal(const internal::RpcMethod& method,
const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context, ClientContext* context,
::grpc::CompletionQueue* cq, size_t interceptor_pos) { CompletionQueue* cq,
size_t interceptor_pos) {
const bool kRegistered = method.channel_tag() && context->authority().empty(); const bool kRegistered = method.channel_tag() && context->authority().empty();
grpc_call* c_call = nullptr; grpc_call* c_call = nullptr;
if (kRegistered) { if (kRegistered) {
@ -119,7 +115,7 @@ void ChannelResetConnectionBackoff(Channel* channel) {
context->propagation_options_.c_bitmask(), cq->cq(), context->propagation_options_.c_bitmask(), cq->cq(),
method.channel_tag(), context->raw_deadline(), nullptr); method.channel_tag(), context->raw_deadline(), nullptr);
} else { } else {
const ::grpc::string* host_str = nullptr; const string* host_str = nullptr;
if (!context->authority_.empty()) { if (!context->authority_.empty()) {
host_str = &context->authority_; host_str = &context->authority_;
} else if (!host_.empty()) { } else if (!host_.empty()) {
@ -129,7 +125,7 @@ void ChannelResetConnectionBackoff(Channel* channel) {
SliceFromArray(method.name(), strlen(method.name())); SliceFromArray(method.name(), strlen(method.name()));
grpc_slice host_slice; grpc_slice host_slice;
if (host_str != nullptr) { if (host_str != nullptr) {
host_slice = ::grpc::SliceFromCopiedString(*host_str); host_slice = SliceFromCopiedString(*host_str);
} }
c_call = grpc_channel_create_call( c_call = grpc_channel_create_call(
c_channel_, context->propagate_from_call_, c_channel_, context->propagate_from_call_,
@ -151,17 +147,17 @@ void ChannelResetConnectionBackoff(Channel* channel) {
interceptor_creators_, interceptor_pos); interceptor_creators_, interceptor_pos);
context->set_call(c_call, shared_from_this()); context->set_call(c_call, shared_from_this());
return ::grpc::internal::Call(c_call, this, cq, info); return internal::Call(c_call, this, cq, info);
} }
::grpc::internal::Call Channel::CreateCall( internal::Call Channel::CreateCall(const internal::RpcMethod& method,
const ::grpc::internal::RpcMethod& method, ::grpc::ClientContext* context, ClientContext* context,
::grpc::CompletionQueue* cq) { CompletionQueue* cq) {
return CreateCallInternal(method, context, cq, 0); return CreateCallInternal(method, context, cq, 0);
} }
void Channel::PerformOpsOnCall(::grpc::internal::CallOpSetInterface* ops, void Channel::PerformOpsOnCall(internal::CallOpSetInterface* ops,
::grpc::internal::Call* call) { internal::Call* call) {
ops->FillOps( ops->FillOps(
call); // Make a copy of call. It's fine since Call just has pointers call); // Make a copy of call. It's fine since Call just has pointers
} }
@ -177,7 +173,7 @@ grpc_connectivity_state Channel::GetState(bool try_to_connect) {
namespace { namespace {
class TagSaver final : public ::grpc::internal::CompletionQueueTag { class TagSaver final : public internal::CompletionQueueTag {
public: public:
explicit TagSaver(void* tag) : tag_(tag) {} explicit TagSaver(void* tag) : tag_(tag) {}
~TagSaver() override {} ~TagSaver() override {}
@ -195,7 +191,7 @@ class TagSaver final : public ::grpc::internal::CompletionQueueTag {
void Channel::NotifyOnStateChangeImpl(grpc_connectivity_state last_observed, void Channel::NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline, gpr_timespec deadline,
::grpc::CompletionQueue* cq, void* tag) { CompletionQueue* cq, void* tag) {
TagSaver* tag_saver = new TagSaver(tag); TagSaver* tag_saver = new TagSaver(tag);
grpc_channel_watch_connectivity_state(c_channel_, last_observed, deadline, grpc_channel_watch_connectivity_state(c_channel_, last_observed, deadline,
cq->cq(), tag_saver); cq->cq(), tag_saver);
@ -203,7 +199,7 @@ void Channel::NotifyOnStateChangeImpl(grpc_connectivity_state last_observed,
bool Channel::WaitForStateChangeImpl(grpc_connectivity_state last_observed, bool Channel::WaitForStateChangeImpl(grpc_connectivity_state last_observed,
gpr_timespec deadline) { gpr_timespec deadline) {
::grpc::CompletionQueue cq; CompletionQueue cq;
bool ok = false; bool ok = false;
void* tag = nullptr; void* tag = nullptr;
NotifyOnStateChangeImpl(last_observed, deadline, &cq, nullptr); NotifyOnStateChangeImpl(last_observed, deadline, &cq, nullptr);
@ -218,7 +214,7 @@ class ShutdownCallback : public grpc_experimental_completion_queue_functor {
ShutdownCallback() { functor_run = &ShutdownCallback::Run; } ShutdownCallback() { functor_run = &ShutdownCallback::Run; }
// TakeCQ takes ownership of the cq into the shutdown callback // TakeCQ takes ownership of the cq into the shutdown callback
// so that the shutdown callback will be responsible for destroying it // so that the shutdown callback will be responsible for destroying it
void TakeCQ(::grpc::CompletionQueue* cq) { cq_ = cq; } void TakeCQ(CompletionQueue* cq) { cq_ = cq; }
// The Run function will get invoked by the completion queue library // The Run function will get invoked by the completion queue library
// when the shutdown is actually complete // when the shutdown is actually complete
@ -229,17 +225,17 @@ class ShutdownCallback : public grpc_experimental_completion_queue_functor {
} }
private: private:
::grpc::CompletionQueue* cq_ = nullptr; CompletionQueue* cq_ = nullptr;
}; };
} // namespace } // namespace
::grpc::CompletionQueue* Channel::CallbackCQ() { CompletionQueue* Channel::CallbackCQ() {
// TODO(vjpai): Consider using a single global CQ for the default CQ // TODO(vjpai): Consider using a single global CQ for the default CQ
// if there is no explicit per-channel CQ registered // if there is no explicit per-channel CQ registered
grpc::internal::MutexLock l(&mu_); grpc::internal::MutexLock l(&mu_);
if (callback_cq_ == nullptr) { if (callback_cq_ == nullptr) {
auto* shutdown_callback = new ShutdownCallback; auto* shutdown_callback = new ShutdownCallback;
callback_cq_ = new ::grpc::CompletionQueue(grpc_completion_queue_attributes{ callback_cq_ = new CompletionQueue(grpc_completion_queue_attributes{
GRPC_CQ_CURRENT_VERSION, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING, GRPC_CQ_CURRENT_VERSION, GRPC_CQ_CALLBACK, GRPC_CQ_DEFAULT_POLLING,
shutdown_callback}); shutdown_callback});
@ -249,4 +245,4 @@ class ShutdownCallback : public grpc_experimental_completion_queue_functor {
return callback_cq_; return callback_cq_;
} }
} // namespace grpc_impl } // namespace grpc

@ -31,11 +31,6 @@
#include <grpcpp/server_context.h> #include <grpcpp/server_context.h>
#include <grpcpp/support/time.h> #include <grpcpp/support/time.h>
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class DefaultGlobalClientCallbacks final class DefaultGlobalClientCallbacks final
@ -88,8 +83,8 @@ void ClientContext::AddMetadata(const grpc::string& meta_key,
send_initial_metadata_.insert(std::make_pair(meta_key, meta_value)); send_initial_metadata_.insert(std::make_pair(meta_key, meta_value));
} }
void ClientContext::set_call( void ClientContext::set_call(grpc_call* call,
grpc_call* call, const std::shared_ptr<::grpc_impl::Channel>& channel) { const std::shared_ptr<Channel>& channel) {
grpc::internal::MutexLock lock(&mu_); grpc::internal::MutexLock lock(&mu_);
GPR_ASSERT(call_ == nullptr); GPR_ASSERT(call_ == nullptr);
call_ = call; call_ = call;

@ -43,7 +43,7 @@ std::shared_ptr<grpc::Channel> CreateCustomChannel(
grpc::GrpcLibraryCodegen grpc::GrpcLibraryCodegen
init_lib; // We need to call init in case of a bad creds. init_lib; // We need to call init in case of a bad creds.
return creds ? creds->CreateChannel(target, args) return creds ? creds->CreateChannel(target, args)
: ::grpc_impl::CreateChannelInternal( : grpc::CreateChannelInternal(
"", "",
grpc_lame_client_channel_create( grpc_lame_client_channel_create(
nullptr, GRPC_STATUS_INVALID_ARGUMENT, nullptr, GRPC_STATUS_INVALID_ARGUMENT,
@ -74,7 +74,7 @@ std::shared_ptr<grpc::Channel> CreateCustomChannelWithInterceptors(
interceptor_creators) { interceptor_creators) {
return creds ? creds->CreateChannelWithInterceptors( return creds ? creds->CreateChannelWithInterceptors(
target, args, std::move(interceptor_creators)) target, args, std::move(interceptor_creators))
: ::grpc_impl::CreateChannelInternal( : grpc::CreateChannelInternal(
"", "",
grpc_lame_client_channel_create( grpc_lame_client_channel_create(
nullptr, GRPC_STATUS_INVALID_ARGUMENT, nullptr, GRPC_STATUS_INVALID_ARGUMENT,

@ -22,15 +22,14 @@
struct grpc_channel; struct grpc_channel;
namespace grpc_impl { namespace grpc {
std::shared_ptr<Channel> CreateChannelInternal( std::shared_ptr<Channel> CreateChannelInternal(
const grpc::string& host, grpc_channel* c_channel, const grpc::string& host, grpc_channel* c_channel,
std::vector<std::unique_ptr< std::vector<
::grpc::experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators) { interceptor_creators) {
return std::shared_ptr<Channel>( return std::shared_ptr<Channel>(
new Channel(host, c_channel, std::move(interceptor_creators))); new Channel(host, c_channel, std::move(interceptor_creators)));
} }
} // namespace grpc
} // namespace grpc_impl

@ -26,16 +26,15 @@
struct grpc_channel; struct grpc_channel;
namespace grpc_impl { namespace grpc {
class Channel; class Channel;
std::shared_ptr<Channel> CreateChannelInternal( std::shared_ptr<Channel> CreateChannelInternal(
const grpc::string& host, grpc_channel* c_channel, const grpc::string& host, grpc_channel* c_channel,
std::vector<std::unique_ptr< std::vector<
::grpc::experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators); interceptor_creators);
} // namespace grpc_impl } // namespace grpc
#endif // GRPC_INTERNAL_CPP_CLIENT_CREATE_CHANNEL_INTERNAL_H #endif // GRPC_INTERNAL_CPP_CLIENT_CREATE_CHANNEL_INTERNAL_H

@ -32,7 +32,7 @@ std::shared_ptr<grpc::Channel> CreateInsecureChannelFromFd(
const grpc::string& target, int fd) { const grpc::string& target, int fd) {
grpc::internal::GrpcLibrary init_lib; grpc::internal::GrpcLibrary init_lib;
init_lib.init(); init_lib.init();
return ::grpc_impl::CreateChannelInternal( return grpc::CreateChannelInternal(
"", grpc_insecure_channel_create_from_fd(target.c_str(), fd, nullptr), "", grpc_insecure_channel_create_from_fd(target.c_str(), fd, nullptr),
std::vector<std::unique_ptr< std::vector<std::unique_ptr<
grpc::experimental::ClientInterceptorFactoryInterface>>()); grpc::experimental::ClientInterceptorFactoryInterface>>());
@ -44,7 +44,7 @@ std::shared_ptr<grpc::Channel> CreateCustomInsecureChannelFromFd(
init_lib.init(); init_lib.init();
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return ::grpc_impl::CreateChannelInternal( return grpc::CreateChannelInternal(
"", "",
grpc_insecure_channel_create_from_fd(target.c_str(), fd, &channel_args), grpc_insecure_channel_create_from_fd(target.c_str(), fd, &channel_args),
std::vector<std::unique_ptr< std::vector<std::unique_ptr<
@ -63,7 +63,7 @@ CreateCustomInsecureChannelWithInterceptorsFromFd(
init_lib.init(); init_lib.init();
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return ::grpc_impl::CreateChannelInternal( return grpc::CreateChannelInternal(
"", "",
grpc_insecure_channel_create_from_fd(target.c_str(), fd, &channel_args), grpc_insecure_channel_create_from_fd(target.c_str(), fd, &channel_args),
std::move(interceptor_creators)); std::move(interceptor_creators));

@ -47,7 +47,7 @@ class CronetChannelCredentialsImpl final : public ChannelCredentials {
interceptor_creators) override { interceptor_creators) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return ::grpc_impl::CreateChannelInternal( return CreateChannelInternal(
"", "",
grpc_cronet_secure_channel_create(engine_, target.c_str(), grpc_cronet_secure_channel_create(engine_, target.c_str(),
&channel_args, nullptr), &channel_args, nullptr),

@ -45,7 +45,7 @@ class InsecureChannelCredentialsImpl final : public ChannelCredentials {
interceptor_creators) override { interceptor_creators) override {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return ::grpc_impl::CreateChannelInternal( return CreateChannelInternal(
"", "",
grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr), grpc_insecure_channel_create(target.c_str(), &channel_args, nullptr),
std::move(interceptor_creators)); std::move(interceptor_creators));

@ -50,7 +50,7 @@ SecureChannelCredentials::CreateChannelWithInterceptors(
interceptor_creators) { interceptor_creators) {
grpc_channel_args channel_args; grpc_channel_args channel_args;
args.SetChannelArgs(&channel_args); args.SetChannelArgs(&channel_args);
return ::grpc_impl::CreateChannelInternal( return CreateChannelInternal(
args.GetSslTargetNameOverride(), args.GetSslTargetNameOverride(),
grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args, grpc_secure_channel_create(c_creds_, target.c_str(), &channel_args,
nullptr), nullptr),

@ -27,11 +27,6 @@
#include "src/core/lib/security/credentials/credentials.h" #include "src/core/lib/security/credentials/credentials.h"
#include "src/cpp/server/thread_pool_interface.h" #include "src/cpp/server/thread_pool_interface.h"
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class SecureChannelCredentials final : public ChannelCredentials { class SecureChannelCredentials final : public ChannelCredentials {
@ -42,13 +37,13 @@ class SecureChannelCredentials final : public ChannelCredentials {
} }
grpc_channel_credentials* GetRawCreds() { return c_creds_; } grpc_channel_credentials* GetRawCreds() { return c_creds_; }
std::shared_ptr<::grpc_impl::Channel> CreateChannel( std::shared_ptr<grpc::Channel> CreateChannel(
const string& target, const grpc::ChannelArguments& args) override; const string& target, const grpc::ChannelArguments& args) override;
SecureChannelCredentials* AsSecureCredentials() override { return this; } SecureChannelCredentials* AsSecureCredentials() override { return this; }
private: private:
std::shared_ptr<::grpc_impl::Channel> CreateChannelWithInterceptors( std::shared_ptr<grpc::Channel> CreateChannelWithInterceptors(
const string& target, const grpc::ChannelArguments& args, const string& target, const grpc::ChannelArguments& args,
std::vector< std::vector<
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>

@ -1028,7 +1028,7 @@ grpc_server* Server::c_server() { return server_; }
std::shared_ptr<grpc::Channel> Server::InProcessChannel( std::shared_ptr<grpc::Channel> Server::InProcessChannel(
const grpc::ChannelArguments& args) { const grpc::ChannelArguments& args) {
grpc_channel_args channel_args = args.c_channel_args(); grpc_channel_args channel_args = args.c_channel_args();
return ::grpc_impl::CreateChannelInternal( return grpc::CreateChannelInternal(
"inproc", grpc_inproc_channel_create(server_, &channel_args, nullptr), "inproc", grpc_inproc_channel_create(server_, &channel_args, nullptr),
std::vector<std::unique_ptr< std::vector<std::unique_ptr<
grpc::experimental::ClientInterceptorFactoryInterface>>()); grpc::experimental::ClientInterceptorFactoryInterface>>());
@ -1041,7 +1041,7 @@ Server::experimental_type::InProcessChannelWithInterceptors(
std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>
interceptor_creators) { interceptor_creators) {
grpc_channel_args channel_args = args.c_channel_args(); grpc_channel_args channel_args = args.c_channel_args();
return ::grpc_impl::CreateChannelInternal( return grpc::CreateChannelInternal(
"inproc", "inproc",
grpc_inproc_channel_create(server_->server_, &channel_args, nullptr), grpc_inproc_channel_create(server_->server_, &channel_args, nullptr),
std::move(interceptor_creators)); std::move(interceptor_creators));

@ -40,12 +40,9 @@
#include <grpcpp/impl/codegen/stub_options.h> #include <grpcpp/impl/codegen/stub_options.h>
#include <grpcpp/impl/codegen/sync_stream.h> #include <grpcpp/impl/codegen/sync_stream.h>
namespace grpc_impl {
class Channel;
} // namespace grpc_impl
namespace grpc { namespace grpc {
class CompletionQueue; class CompletionQueue;
class Channel;
class ServerCompletionQueue; class ServerCompletionQueue;
class ServerContext; class ServerContext;
} // namespace grpc } // namespace grpc

@ -31,7 +31,7 @@ using namespace gflags;
DEFINE_string( DEFINE_string(
generated_file_path, "", generated_file_path, "",
"path to the directory containing generated files compiler_test.grpc.pb.h " "path to the directory containing generated files compiler_test.grpc.pb.h"
"and compiler_test_mock.grpc.pb.h"); "and compiler_test_mock.grpc.pb.h");
const char kGoldenFilePath[] = "test/cpp/codegen/compiler_test_golden"; const char kGoldenFilePath[] = "test/cpp/codegen/compiler_test_golden";

@ -131,7 +131,7 @@ static void* tag(int i) {
static void BM_LameChannelCallCreateCpp(benchmark::State& state) { static void BM_LameChannelCallCreateCpp(benchmark::State& state) {
TrackCounters track_counters; TrackCounters track_counters;
auto stub = auto stub =
grpc::testing::EchoTestService::NewStub(grpc_impl::CreateChannelInternal( grpc::testing::EchoTestService::NewStub(grpc::CreateChannelInternal(
"", "",
grpc_lame_client_channel_create("localhost:1234", grpc_lame_client_channel_create("localhost:1234",
GRPC_STATUS_UNAUTHENTICATED, "blah"), GRPC_STATUS_UNAUTHENTICATED, "blah"),

@ -218,7 +218,7 @@ class EndpointPairFixture : public BaseFixture {
"target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport_); "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, client_transport_);
grpc_chttp2_transport_start_reading(client_transport_, nullptr, nullptr); grpc_chttp2_transport_start_reading(client_transport_, nullptr, nullptr);
channel_ = ::grpc_impl::CreateChannelInternal( channel_ = CreateChannelInternal(
"", channel, "", channel,
std::vector<std::unique_ptr< std::vector<std::unique_ptr<
experimental::ClientInterceptorFactoryInterface>>()); experimental::ClientInterceptorFactoryInterface>>());

@ -118,7 +118,7 @@ class EndpointPairFixture {
"target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, transport); "target", &c_args, GRPC_CLIENT_DIRECT_CHANNEL, transport);
grpc_chttp2_transport_start_reading(transport, nullptr, nullptr); grpc_chttp2_transport_start_reading(transport, nullptr, nullptr);
channel_ = ::grpc_impl::CreateChannelInternal( channel_ = CreateChannelInternal(
"", channel, "", channel,
std::vector<std::unique_ptr< std::vector<std::unique_ptr<
experimental::ClientInterceptorFactoryInterface>>()); experimental::ClientInterceptorFactoryInterface>>());

@ -24,12 +24,8 @@
#include <grpcpp/impl/codegen/client_interceptor.h> #include <grpcpp/impl/codegen/client_interceptor.h>
#include <grpcpp/security/credentials.h> #include <grpcpp/security/credentials.h>
namespace grpc_impl {
class Channel;
}
namespace grpc { namespace grpc {
class Channel;
namespace testing { namespace testing {
@ -37,35 +33,35 @@ typedef enum { INSECURE = 0, TLS, ALTS } transport_security;
} // namespace testing } // namespace testing
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, testing::transport_security security_type); const grpc::string& server, testing::transport_security security_type);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& override_hostname, const grpc::string& server, const grpc::string& override_hostname,
testing::transport_security security_type, bool use_prod_roots); testing::transport_security security_type, bool use_prod_roots);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& override_hostname, const grpc::string& server, const grpc::string& override_hostname,
testing::transport_security security_type, bool use_prod_roots, testing::transport_security security_type, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds); const std::shared_ptr<CallCredentials>& creds);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& override_hostname, const grpc::string& server, const grpc::string& override_hostname,
testing::transport_security security_type, bool use_prod_roots, testing::transport_security security_type, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds, const std::shared_ptr<CallCredentials>& creds,
const ChannelArguments& args); const ChannelArguments& args);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& cred_type, const grpc::string& server, const grpc::string& cred_type,
const grpc::string& override_hostname, bool use_prod_roots, const grpc::string& override_hostname, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds, const std::shared_ptr<CallCredentials>& creds,
const ChannelArguments& args); const ChannelArguments& args);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& credential_type, const grpc::string& server, const grpc::string& credential_type,
const std::shared_ptr<CallCredentials>& creds); const std::shared_ptr<CallCredentials>& creds);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& override_hostname, const grpc::string& server, const grpc::string& override_hostname,
testing::transport_security security_type, bool use_prod_roots, testing::transport_security security_type, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds, const std::shared_ptr<CallCredentials>& creds,
@ -73,7 +69,7 @@ std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators); interceptor_creators);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& override_hostname, const grpc::string& server, const grpc::string& override_hostname,
testing::transport_security security_type, bool use_prod_roots, testing::transport_security security_type, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds, const ChannelArguments& args, const std::shared_ptr<CallCredentials>& creds, const ChannelArguments& args,
@ -81,7 +77,7 @@ std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators); interceptor_creators);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& cred_type, const grpc::string& server, const grpc::string& cred_type,
const grpc::string& override_hostname, bool use_prod_roots, const grpc::string& override_hostname, bool use_prod_roots,
const std::shared_ptr<CallCredentials>& creds, const ChannelArguments& args, const std::shared_ptr<CallCredentials>& creds, const ChannelArguments& args,
@ -89,7 +85,7 @@ std::shared_ptr<::grpc_impl::Channel> CreateTestChannel(
std::unique_ptr<experimental::ClientInterceptorFactoryInterface>> std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
interceptor_creators); interceptor_creators);
std::shared_ptr<::grpc_impl::Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel(
const grpc::string& server, const grpc::string& credential_type, const grpc::string& server, const grpc::string& credential_type,
const std::shared_ptr<CallCredentials>& creds, const std::shared_ptr<CallCredentials>& creds,
std::vector< std::vector<

@ -927,7 +927,6 @@ include/grpc/support/workaround_list.h \
include/grpcpp/alarm.h \ include/grpcpp/alarm.h \
include/grpcpp/alarm_impl.h \ include/grpcpp/alarm_impl.h \
include/grpcpp/channel.h \ include/grpcpp/channel.h \
include/grpcpp/channel_impl.h \
include/grpcpp/client_context.h \ include/grpcpp/client_context.h \
include/grpcpp/completion_queue.h \ include/grpcpp/completion_queue.h \
include/grpcpp/create_channel.h \ include/grpcpp/create_channel.h \

@ -928,7 +928,6 @@ include/grpc/support/workaround_list.h \
include/grpcpp/alarm.h \ include/grpcpp/alarm.h \
include/grpcpp/alarm_impl.h \ include/grpcpp/alarm_impl.h \
include/grpcpp/channel.h \ include/grpcpp/channel.h \
include/grpcpp/channel_impl.h \
include/grpcpp/client_context.h \ include/grpcpp/client_context.h \
include/grpcpp/completion_queue.h \ include/grpcpp/completion_queue.h \
include/grpcpp/create_channel.h \ include/grpcpp/create_channel.h \

@ -10112,7 +10112,6 @@
"include/grpcpp/alarm.h", "include/grpcpp/alarm.h",
"include/grpcpp/alarm_impl.h", "include/grpcpp/alarm_impl.h",
"include/grpcpp/channel.h", "include/grpcpp/channel.h",
"include/grpcpp/channel_impl.h",
"include/grpcpp/client_context.h", "include/grpcpp/client_context.h",
"include/grpcpp/completion_queue.h", "include/grpcpp/completion_queue.h",
"include/grpcpp/create_channel.h", "include/grpcpp/create_channel.h",
@ -10234,7 +10233,6 @@
"include/grpcpp/alarm.h", "include/grpcpp/alarm.h",
"include/grpcpp/alarm_impl.h", "include/grpcpp/alarm_impl.h",
"include/grpcpp/channel.h", "include/grpcpp/channel.h",
"include/grpcpp/channel_impl.h",
"include/grpcpp/client_context.h", "include/grpcpp/client_context.h",
"include/grpcpp/completion_queue.h", "include/grpcpp/completion_queue.h",
"include/grpcpp/create_channel.h", "include/grpcpp/create_channel.h",

Loading…
Cancel
Save