Merge pull request #17232 from yashykt/cleanup1

Remove the std::unique_ptr for interceptor creators, instead use move semantics everywhere

include/grpcpp/channel.h

@@ -65,13 +65,13 @@ class Channel final : public ChannelInterface,
   friend void experimental::ChannelResetConnectionBackoff(Channel* channel);
   friend std::shared_ptr<Channel> CreateChannelInternal(
       const grpc::string& host, grpc_channel* c_channel,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators);
   friend class internal::InterceptedChannel;
   Channel(const grpc::string& host, grpc_channel* c_channel,
-          std::unique_ptr<std::vector<
+          std::vector<
-              std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+              std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
               interceptor_creators);
 
   internal::Call CreateCall(const internal::RpcMethod& method,

include/grpcpp/create_channel.h

@@ -70,8 +70,8 @@ std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
     const grpc::string& target,
     const std::shared_ptr<ChannelCredentials>& creds,
     const ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators);
 }  // namespace experimental
 }  // namespace grpc

include/grpcpp/security/credentials.h

@@ -46,8 +46,8 @@ std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
     const grpc::string& target,
     const std::shared_ptr<ChannelCredentials>& creds,
     const ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators);
 }  // namespace experimental
 
@@ -80,8 +80,8 @@ class ChannelCredentials : private GrpcLibraryCodegen {
       const grpc::string& target,
       const std::shared_ptr<ChannelCredentials>& creds,
       const ChannelArguments& args,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators);
 
   virtual std::shared_ptr<Channel> CreateChannel(
@@ -91,8 +91,8 @@ class ChannelCredentials : private GrpcLibraryCodegen {
   // implemented as a virtual function so that it does not break API.
   virtual std::shared_ptr<Channel> CreateChannelWithInterceptors(
       const grpc::string& target, const ChannelArguments& args,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) {
     return nullptr;
   };

include/grpcpp/server.h

@@ -111,8 +111,8 @@ class Server : public ServerInterface, private GrpcLibraryCodegen {
     /// interceptors
     std::shared_ptr<Channel> InProcessChannelWithInterceptors(
         const ChannelArguments& args,
-        std::unique_ptr<std::vector<
+        std::vector<
-            std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+            std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
             interceptor_creators);
 
    private:

src/cpp/client/channel_cc.cc

@@ -54,13 +54,11 @@ namespace grpc {
 static internal::GrpcLibraryInitializer g_gli_initializer;
 Channel::Channel(
     const grpc::string& host, grpc_channel* channel,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators)
     : host_(host), c_channel_(channel) {
-  if (interceptor_creators != nullptr) {
+  interceptor_creators_ = std::move(interceptor_creators);
-    interceptor_creators_ = std::move(*interceptor_creators);
-  }
   g_gli_initializer.summon();
 }
 

src/cpp/client/create_channel.cc

@@ -39,13 +39,14 @@ std::shared_ptr<Channel> CreateCustomChannel(
     const std::shared_ptr<ChannelCredentials>& creds,
     const ChannelArguments& args) {
   GrpcLibraryCodegen init_lib;  // We need to call init in case of a bad creds.
-  return creds
+  return creds ? creds->CreateChannel(target, args)
-             ? creds->CreateChannel(target, args)
+               : CreateChannelInternal(
-             : CreateChannelInternal("",
+                     "",
-                                     grpc_lame_client_channel_create(
+                     grpc_lame_client_channel_create(
-                                         nullptr, GRPC_STATUS_INVALID_ARGUMENT,
+                         nullptr, GRPC_STATUS_INVALID_ARGUMENT,
-                                         "Invalid credentials."),
+                         "Invalid credentials."),
-                                     nullptr);
+                     std::vector<std::unique_ptr<
+                         experimental::ClientInterceptorFactoryInterface>>());
 }
 
 namespace experimental {
@@ -64,17 +65,18 @@ std::shared_ptr<Channel> CreateCustomChannelWithInterceptors(
     const grpc::string& target,
     const std::shared_ptr<ChannelCredentials>& creds,
     const ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
-  return creds
+  return creds ? creds->CreateChannelWithInterceptors(
-             ? creds->CreateChannelWithInterceptors(
+                     target, args, std::move(interceptor_creators))
-                   target, args, std::move(interceptor_creators))
+               : CreateChannelInternal(
-             : CreateChannelInternal("",
+                     "",
-                                     grpc_lame_client_channel_create(
+                     grpc_lame_client_channel_create(
-                                         nullptr, GRPC_STATUS_INVALID_ARGUMENT,
+                         nullptr, GRPC_STATUS_INVALID_ARGUMENT,
-                                         "Invalid credentials."),
+                         "Invalid credentials."),
-                                     nullptr);
+                     std::vector<std::unique_ptr<
+                         experimental::ClientInterceptorFactoryInterface>>());
 }
 }  // namespace experimental
 

src/cpp/client/create_channel_internal.cc

@@ -26,8 +26,8 @@ namespace grpc {
 
 std::shared_ptr<Channel> CreateChannelInternal(
     const grpc::string& host, grpc_channel* c_channel,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
   return std::shared_ptr<Channel>(
       new Channel(host, c_channel, std::move(interceptor_creators)));

src/cpp/client/create_channel_internal.h

@@ -31,8 +31,8 @@ class Channel;
 
 std::shared_ptr<Channel> CreateChannelInternal(
     const grpc::string& host, grpc_channel* c_channel,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators);
 
 }  // namespace grpc

src/cpp/client/create_channel_posix.cc

@@ -34,7 +34,8 @@ std::shared_ptr<Channel> CreateInsecureChannelFromFd(const grpc::string& target,
   init_lib.init();
   return CreateChannelInternal(
       "", grpc_insecure_channel_create_from_fd(target.c_str(), fd, nullptr),
-      nullptr);
+      std::vector<
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
 }
 
 std::shared_ptr<Channel> CreateCustomInsecureChannelFromFd(
@@ -46,15 +47,16 @@ std::shared_ptr<Channel> CreateCustomInsecureChannelFromFd(
   return CreateChannelInternal(
       "",
       grpc_insecure_channel_create_from_fd(target.c_str(), fd, &channel_args),
-      nullptr);
+      std::vector<
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
 }
 
 namespace experimental {
 
 std::shared_ptr<Channel> CreateCustomInsecureChannelWithInterceptorsFromFd(
     const grpc::string& target, int fd, const ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
   internal::GrpcLibrary init_lib;
   init_lib.init();

src/cpp/client/cronet_credentials.cc

@@ -31,7 +31,10 @@ class CronetChannelCredentialsImpl final : public ChannelCredentials {
 
   std::shared_ptr<grpc::Channel> CreateChannel(
       const string& target, const grpc::ChannelArguments& args) override {
-    return CreateChannelWithInterceptors(target, args, nullptr);
+    return CreateChannelWithInterceptors(
+        target, args,
+        std::vector<std::unique_ptr<
+            experimental::ClientInterceptorFactoryInterface>>());
   }
 
   SecureChannelCredentials* AsSecureCredentials() override { return nullptr; }
@@ -39,8 +42,8 @@ class CronetChannelCredentialsImpl final : public ChannelCredentials {
  private:
   std::shared_ptr<grpc::Channel> CreateChannelWithInterceptors(
       const string& target, const grpc::ChannelArguments& args,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) override {
     grpc_channel_args channel_args;
     args.SetChannelArgs(&channel_args);

src/cpp/client/insecure_credentials.cc

@@ -32,13 +32,16 @@ class InsecureChannelCredentialsImpl final : public ChannelCredentials {
  public:
   std::shared_ptr<grpc::Channel> CreateChannel(
       const string& target, const grpc::ChannelArguments& args) override {
-    return CreateChannelWithInterceptors(target, args, nullptr);
+    return CreateChannelWithInterceptors(
+        target, args,
+        std::vector<std::unique_ptr<
+            experimental::ClientInterceptorFactoryInterface>>());
   }
 
   std::shared_ptr<grpc::Channel> CreateChannelWithInterceptors(
       const string& target, const grpc::ChannelArguments& args,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) override {
     grpc_channel_args channel_args;
     args.SetChannelArgs(&channel_args);

src/cpp/client/secure_credentials.cc

@@ -36,14 +36,17 @@ SecureChannelCredentials::SecureChannelCredentials(
 
 std::shared_ptr<grpc::Channel> SecureChannelCredentials::CreateChannel(
     const string& target, const grpc::ChannelArguments& args) {
-  return CreateChannelWithInterceptors(target, args, nullptr);
+  return CreateChannelWithInterceptors(
+      target, args,
+      std::vector<
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
 }
 
 std::shared_ptr<grpc::Channel>
 SecureChannelCredentials::CreateChannelWithInterceptors(
     const string& target, const grpc::ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
   grpc_channel_args channel_args;
   args.SetChannelArgs(&channel_args);

src/cpp/client/secure_credentials.h

@@ -42,8 +42,8 @@ class SecureChannelCredentials final : public ChannelCredentials {
  private:
   std::shared_ptr<grpc::Channel> CreateChannelWithInterceptors(
       const string& target, const grpc::ChannelArguments& args,
-      std::unique_ptr<std::vector<
+      std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
           interceptor_creators) override;
   grpc_channel_credentials* const c_creds_;
 };

src/cpp/server/server_cc.cc

@@ -732,14 +732,15 @@ std::shared_ptr<Channel> Server::InProcessChannel(
   grpc_channel_args channel_args = args.c_channel_args();
   return CreateChannelInternal(
       "inproc", grpc_inproc_channel_create(server_, &channel_args, nullptr),
-      nullptr);
+      std::vector<
+          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
 }
 
 std::shared_ptr<Channel>
 Server::experimental_type::InProcessChannelWithInterceptors(
     const ChannelArguments& args,
-    std::unique_ptr<std::vector<
+    std::vector<
-        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
+        std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
         interceptor_creators) {
   grpc_channel_args channel_args = args.c_channel_args();
   return CreateChannelInternal(

test/cpp/end2end/client_interceptors_end2end_test.cc

@@ -361,15 +361,13 @@ class ClientInterceptorsEnd2endTest : public ::testing::Test {
 TEST_F(ClientInterceptorsEnd2endTest, ClientInterceptorLoggingTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -382,20 +380,18 @@ TEST_F(ClientInterceptorsEnd2endTest, ClientInterceptorLoggingTest) {
 TEST_F(ClientInterceptorsEnd2endTest, ClientInterceptorHijackingTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 20 dummy interceptors before hijacking interceptor
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
-  creators->push_back(std::unique_ptr<HijackingInterceptorFactory>(
+  creators.push_back(std::unique_ptr<HijackingInterceptorFactory>(
       new HijackingInterceptorFactory()));
   // Add 20 dummy interceptors after hijacking interceptor
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -408,13 +404,11 @@ TEST_F(ClientInterceptorsEnd2endTest, ClientInterceptorHijackingTest) {
 
 TEST_F(ClientInterceptorsEnd2endTest, ClientInterceptorLogThenHijackTest) {
   ChannelArguments args;
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
-  creators->push_back(std::unique_ptr<HijackingInterceptorFactory>(
+  creators.push_back(std::unique_ptr<HijackingInterceptorFactory>(
       new HijackingInterceptorFactory()));
   auto channel = experimental::CreateCustomChannelWithInterceptors(
       server_address_, InsecureChannelCredentials(), args, std::move(creators));
@@ -426,21 +420,19 @@ TEST_F(ClientInterceptorsEnd2endTest,
        ClientInterceptorHijackingMakesAnotherCallTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 5 dummy interceptors before hijacking interceptor
   for (auto i = 0; i < 5; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
-  creators->push_back(
+  creators.push_back(
       std::unique_ptr<experimental::ClientInterceptorFactoryInterface>(
           new HijackingInterceptorMakesAnotherCallFactory()));
   // Add 7 dummy interceptors after hijacking interceptor
   for (auto i = 0; i < 7; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = server_->experimental().InProcessChannelWithInterceptors(
@@ -456,15 +448,13 @@ TEST_F(ClientInterceptorsEnd2endTest,
        ClientInterceptorLoggingTestWithCallback) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = server_->experimental().InProcessChannelWithInterceptors(
@@ -496,15 +486,13 @@ class ClientInterceptorsStreamingEnd2endTest : public ::testing::Test {
 TEST_F(ClientInterceptorsStreamingEnd2endTest, ClientStreamingTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -517,15 +505,13 @@ TEST_F(ClientInterceptorsStreamingEnd2endTest, ClientStreamingTest) {
 TEST_F(ClientInterceptorsStreamingEnd2endTest, ServerStreamingTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -538,15 +524,13 @@ TEST_F(ClientInterceptorsStreamingEnd2endTest, ServerStreamingTest) {
 TEST_F(ClientInterceptorsStreamingEnd2endTest, BidiStreamingTest) {
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
+  creators.push_back(std::unique_ptr<LoggingInterceptorFactory>(
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
-  creators->push_back(std::unique_ptr<LoggingInterceptorFactory>(
       new LoggingInterceptorFactory()));
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -583,13 +567,11 @@ TEST_F(ClientGlobalInterceptorEnd2endTest, DummyGlobalInterceptor) {
   experimental::RegisterGlobalClientInterceptorFactory(&global_factory);
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -610,13 +592,11 @@ TEST_F(ClientGlobalInterceptorEnd2endTest, LoggingGlobalInterceptor) {
   experimental::RegisterGlobalClientInterceptorFactory(&global_factory);
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(
@@ -637,13 +617,11 @@ TEST_F(ClientGlobalInterceptorEnd2endTest, HijackingGlobalInterceptor) {
   experimental::RegisterGlobalClientInterceptorFactory(&global_factory);
   ChannelArguments args;
   DummyInterceptor::Reset();
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 20 dummy interceptors
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   auto channel = experimental::CreateCustomChannelWithInterceptors(

test/cpp/end2end/interceptors_util.cc

@@ -132,16 +132,13 @@ bool CheckMetadata(const std::multimap<grpc::string_ref, grpc::string_ref>& map,
   return false;
 }
 
-std::unique_ptr<std::vector<
+std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-    std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
 CreateDummyClientInterceptors() {
-  auto creators = std::unique_ptr<std::vector<
+  std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-      std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>(
+      creators;
-      new std::vector<
-          std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>());
   // Add 20 dummy interceptors before hijacking interceptor
   for (auto i = 0; i < 20; i++) {
-    creators->push_back(std::unique_ptr<DummyInterceptorFactory>(
+    creators.push_back(std::unique_ptr<DummyInterceptorFactory>(
         new DummyInterceptorFactory()));
   }
   return creators;

test/cpp/end2end/interceptors_util.h

@@ -149,8 +149,7 @@ void MakeCallbackCall(const std::shared_ptr<Channel>& channel);
 bool CheckMetadata(const std::multimap<grpc::string_ref, grpc::string_ref>& map,
                    const string& key, const string& value);
 
-std::unique_ptr<std::vector<
+std::vector<std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>
-    std::unique_ptr<experimental::ClientInterceptorFactoryInterface>>>
 CreateDummyClientInterceptors();
 
 inline void* tag(int i) { return (void*)static_cast<intptr_t>(i); }

test/cpp/microbenchmarks/bm_call_create.cc

@@ -135,7 +135,8 @@ static void BM_LameChannelCallCreateCpp(benchmark::State& state) {
           "",
           grpc_lame_client_channel_create("localhost:1234",
                                           GRPC_STATUS_UNAUTHENTICATED, "blah"),
-          nullptr));
+          std::vector<std::unique_ptr<
+              grpc::experimental::ClientInterceptorFactoryInterface>>()));
   grpc::CompletionQueue cq;
   grpc::testing::EchoRequest send_request;
   grpc::testing::EchoResponse recv_response;

test/cpp/microbenchmarks/fullstack_fixtures.h

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

test/cpp/performance/writes_per_rpc_test.cc

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