1 files changed, 188 insertions, 151 deletions

diff --git a/src/objective-c/GRPCClient/private/GRPCChannel.m b/src/objective-c/GRPCClient/private/GRPCChannel.m
index b1f6ea270e..1a79fb04a0 100644
--- a/src/objective-c/GRPCClient/private/GRPCChannel.m
+++ b/src/objective-c/GRPCClient/private/GRPCChannel.m
@@ -18,206 +18,243 @@
 
 #import "GRPCChannel.h"
 
-#include <grpc/grpc_security.h>
-#ifdef GRPC_COMPILE_WITH_CRONET
-#include <grpc/grpc_cronet.h>
-#endif
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#ifdef GRPC_COMPILE_WITH_CRONET
-#import <Cronet/Cronet.h>
-#import <GRPCClient/GRPCCall+Cronet.h>
-#endif
+#import "../internal/GRPCCallOptions+Internal.h"
+#import "ChannelArgsUtil.h"
+#import "GRPCChannelFactory.h"
+#import "GRPCChannelPool.h"
 #import "GRPCCompletionQueue.h"
+#import "GRPCCronetChannelFactory.h"
+#import "GRPCInsecureChannelFactory.h"
+#import "GRPCSecureChannelFactory.h"
+#import "version.h"
 
-static void *copy_pointer_arg(void *p) {
-  // Add ref count to the object when making copy
-  id obj = (__bridge id)p;
-  return (__bridge_retained void *)obj;
-}
+#import <GRPCClient/GRPCCall+Cronet.h>
+#import <GRPCClient/GRPCCallOptions.h>
 
-static void destroy_pointer_arg(void *p) {
-  // Decrease ref count to the object when destroying
-  CFRelease((CFTreeRef)p);
-}
+@implementation GRPCChannelConfiguration
 
-static int cmp_pointer_arg(void *p, void *q) { return p == q; }
+- (instancetype)initWithHost:(NSString *)host callOptions:(GRPCCallOptions *)callOptions {
+  NSAssert(host.length > 0, @"Host must not be empty.");
+  NSAssert(callOptions != nil, @"callOptions must not be empty.");
+  if (host.length == 0 || callOptions == nil) {
+    return nil;
+  }
 
-static const grpc_arg_pointer_vtable objc_arg_vtable = {copy_pointer_arg, destroy_pointer_arg,
-                                                        cmp_pointer_arg};
+  if ((self = [super init])) {
+    _host = [host copy];
+    _callOptions = [callOptions copy];
+  }
+  return self;
+}
 
-static void FreeChannelArgs(grpc_channel_args *channel_args) {
-  for (size_t i = 0; i < channel_args->num_args; ++i) {
-    grpc_arg *arg = &channel_args->args[i];
-    gpr_free(arg->key);
-    if (arg->type == GRPC_ARG_STRING) {
-      gpr_free(arg->value.string);
-    }
+- (id<GRPCChannelFactory>)channelFactory {
+  GRPCTransportType type = _callOptions.transportType;
+  switch (type) {
+    case GRPCTransportTypeChttp2BoringSSL:
+      // TODO (mxyan): Remove when the API is deprecated
+#ifdef GRPC_COMPILE_WITH_CRONET
+      if (![GRPCCall isUsingCronet]) {
+#else
+    {
+#endif
+        NSError *error;
+        id<GRPCChannelFactory> factory = [GRPCSecureChannelFactory
+            factoryWithPEMRootCertificates:_callOptions.PEMRootCertificates
+                                privateKey:_callOptions.PEMPrivateKey
+                                 certChain:_callOptions.PEMCertificateChain
+                                     error:&error];
+        NSAssert(factory != nil, @"Failed to create secure channel factory");
+        if (factory == nil) {
+          NSLog(@"Error creating secure channel factory: %@", error);
+        }
+        return factory;
+      }
+      // fallthrough
+    case GRPCTransportTypeCronet:
+      return [GRPCCronetChannelFactory sharedInstance];
+    case GRPCTransportTypeInsecure:
+      return [GRPCInsecureChannelFactory sharedInstance];
   }
-  gpr_free(channel_args->args);
-  gpr_free(channel_args);
 }
 
-/**
- * Allocates a @c grpc_channel_args and populates it with the options specified in the
- * @c dictionary. Keys must be @c NSString. If the value responds to @c @selector(UTF8String) then
- * it will be mapped to @c GRPC_ARG_STRING. If not, it will be mapped to @c GRPC_ARG_INTEGER if the
- * value responds to @c @selector(intValue). Otherwise, an exception will be raised. The caller of
- * this function is responsible for calling @c freeChannelArgs on a non-NULL returned value.
- */
-static grpc_channel_args *BuildChannelArgs(NSDictionary *dictionary) {
-  if (!dictionary) {
-    return NULL;
-  }
-
-  NSArray *keys = [dictionary allKeys];
-  NSUInteger argCount = [keys count];
-
-  grpc_channel_args *channelArgs = gpr_malloc(sizeof(grpc_channel_args));
-  channelArgs->num_args = argCount;
-  channelArgs->args = gpr_malloc(argCount * sizeof(grpc_arg));
-
-  // TODO(kriswuollett) Check that keys adhere to GRPC core library requirements
-
-  for (NSUInteger i = 0; i < argCount; ++i) {
-    grpc_arg *arg = &channelArgs->args[i];
-    arg->key = gpr_strdup([keys[i] UTF8String]);
-
-    id value = dictionary[keys[i]];
-    if ([value respondsToSelector:@selector(UTF8String)]) {
-      arg->type = GRPC_ARG_STRING;
-      arg->value.string = gpr_strdup([value UTF8String]);
-    } else if ([value respondsToSelector:@selector(intValue)]) {
-      arg->type = GRPC_ARG_INTEGER;
-      arg->value.integer = [value intValue];
-    } else if (value != nil) {
-      arg->type = GRPC_ARG_POINTER;
-      arg->value.pointer.p = (__bridge_retained void *)value;
-      arg->value.pointer.vtable = &objc_arg_vtable;
-    } else {
-      [NSException raise:NSInvalidArgumentException
-                  format:@"Invalid value type: %@", [value class]];
-    }
+- (NSDictionary *)channelArgs {
+  NSMutableDictionary *args = [NSMutableDictionary new];
+
+  NSString *userAgent = @"grpc-objc/" GRPC_OBJC_VERSION_STRING;
+  NSString *userAgentPrefix = _callOptions.userAgentPrefix;
+  if (userAgentPrefix.length != 0) {
+    args[@GRPC_ARG_PRIMARY_USER_AGENT_STRING] =
+        [_callOptions.userAgentPrefix stringByAppendingFormat:@" %@", userAgent];
+  } else {
+    args[@GRPC_ARG_PRIMARY_USER_AGENT_STRING] = userAgent;
   }
 
-  return channelArgs;
-}
+  NSString *hostNameOverride = _callOptions.hostNameOverride;
+  if (hostNameOverride) {
+    args[@GRPC_SSL_TARGET_NAME_OVERRIDE_ARG] = hostNameOverride;
+  }
 
-@implementation GRPCChannel {
-  // Retain arguments to channel_create because they may not be used on the thread that invoked
-  // the channel_create function.
-  NSString *_host;
-  grpc_channel_args *_channelArgs;
-}
+  if (_callOptions.responseSizeLimit) {
+    args[@GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH] =
+        [NSNumber numberWithUnsignedInteger:_callOptions.responseSizeLimit];
+  }
 
-#ifdef GRPC_COMPILE_WITH_CRONET
-- (instancetype)initWithHost:(NSString *)host
-                cronetEngine:(stream_engine *)cronetEngine
-                 channelArgs:(NSDictionary *)channelArgs {
-  if (!host) {
-    [NSException raise:NSInvalidArgumentException format:@"host argument missing"];
+  if (_callOptions.compressionAlgorithm != GRPC_COMPRESS_NONE) {
+    args[@GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM] =
+        [NSNumber numberWithInt:_callOptions.compressionAlgorithm];
   }
 
-  if (self = [super init]) {
-    _channelArgs = BuildChannelArgs(channelArgs);
-    _host = [host copy];
-    _unmanagedChannel =
-        grpc_cronet_secure_channel_create(cronetEngine, _host.UTF8String, _channelArgs, NULL);
+  if (_callOptions.keepaliveInterval != 0) {
+    args[@GRPC_ARG_KEEPALIVE_TIME_MS] =
+        [NSNumber numberWithUnsignedInteger:(NSUInteger)(_callOptions.keepaliveInterval * 1000)];
+    args[@GRPC_ARG_KEEPALIVE_TIMEOUT_MS] =
+        [NSNumber numberWithUnsignedInteger:(NSUInteger)(_callOptions.keepaliveTimeout * 1000)];
   }
 
-  return self;
-}
-#endif
+  if (!_callOptions.retryEnabled) {
+    args[@GRPC_ARG_ENABLE_RETRIES] = [NSNumber numberWithInt:_callOptions.retryEnabled ? 1 : 0];
+  }
 
-- (instancetype)initWithHost:(NSString *)host
-                      secure:(BOOL)secure
-                 credentials:(struct grpc_channel_credentials *)credentials
-                 channelArgs:(NSDictionary *)channelArgs {
-  if (!host) {
-    [NSException raise:NSInvalidArgumentException format:@"host argument missing"];
+  if (_callOptions.connectMinTimeout > 0) {
+    args[@GRPC_ARG_MIN_RECONNECT_BACKOFF_MS] =
+        [NSNumber numberWithUnsignedInteger:(NSUInteger)(_callOptions.connectMinTimeout * 1000)];
+  }
+  if (_callOptions.connectInitialBackoff > 0) {
+    args[@GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS] = [NSNumber
+        numberWithUnsignedInteger:(NSUInteger)(_callOptions.connectInitialBackoff * 1000)];
+  }
+  if (_callOptions.connectMaxBackoff > 0) {
+    args[@GRPC_ARG_MAX_RECONNECT_BACKOFF_MS] =
+        [NSNumber numberWithUnsignedInteger:(NSUInteger)(_callOptions.connectMaxBackoff * 1000)];
   }
 
-  if (secure && !credentials) {
-    return nil;
+  if (_callOptions.logContext != nil) {
+    args[@GRPC_ARG_MOBILE_LOG_CONTEXT] = _callOptions.logContext;
   }
 
-  if (self = [super init]) {
-    _channelArgs = BuildChannelArgs(channelArgs);
-    _host = [host copy];
-    if (secure) {
-      _unmanagedChannel =
-          grpc_secure_channel_create(credentials, _host.UTF8String, _channelArgs, NULL);
-    } else {
-      _unmanagedChannel = grpc_insecure_channel_create(_host.UTF8String, _channelArgs, NULL);
-    }
+  if (_callOptions.channelPoolDomain.length != 0) {
+    args[@GRPC_ARG_CHANNEL_POOL_DOMAIN] = _callOptions.channelPoolDomain;
   }
 
-  return self;
+  [args addEntriesFromDictionary:_callOptions.additionalChannelArgs];
+
+  return args;
 }
 
-- (void)dealloc {
-  // TODO(jcanizales): Be sure to add a test with a server that closes the connection prematurely,
-  // as in the past that made this call to crash.
-  grpc_channel_destroy(_unmanagedChannel);
-  FreeChannelArgs(_channelArgs);
+- (id)copyWithZone:(NSZone *)zone {
+  GRPCChannelConfiguration *newConfig =
+      [[GRPCChannelConfiguration alloc] initWithHost:_host callOptions:_callOptions];
+
+  return newConfig;
 }
 
-#ifdef GRPC_COMPILE_WITH_CRONET
-+ (GRPCChannel *)secureCronetChannelWithHost:(NSString *)host
-                                 channelArgs:(NSDictionary *)channelArgs {
-  stream_engine *engine = [GRPCCall cronetEngine];
-  if (!engine) {
-    [NSException raise:NSInvalidArgumentException format:@"cronet_engine is NULL. Set it first."];
-    return nil;
+- (BOOL)isEqual:(id)object {
+  if (![object isKindOfClass:[GRPCChannelConfiguration class]]) {
+    return NO;
   }
-  return [[GRPCChannel alloc] initWithHost:host cronetEngine:engine channelArgs:channelArgs];
-}
-#endif
+  GRPCChannelConfiguration *obj = (GRPCChannelConfiguration *)object;
+  if (!(obj.host == _host || (_host != nil && [obj.host isEqualToString:_host]))) return NO;
+  if (!(obj.callOptions == _callOptions || [obj.callOptions hasChannelOptionsEqualTo:_callOptions]))
+    return NO;
 
-+ (GRPCChannel *)secureChannelWithHost:(NSString *)host {
-  return [[GRPCChannel alloc] initWithHost:host secure:YES credentials:NULL channelArgs:NULL];
+  return YES;
 }
 
-+ (GRPCChannel *)secureChannelWithHost:(NSString *)host
-                           credentials:(struct grpc_channel_credentials *)credentials
-                           channelArgs:(NSDictionary *)channelArgs {
-  return [[GRPCChannel alloc] initWithHost:host
-                                    secure:YES
-                               credentials:credentials
-                               channelArgs:channelArgs];
+- (NSUInteger)hash {
+  NSUInteger result = 31;
+  result ^= _host.hash;
+  result ^= _callOptions.channelOptionsHash;
+
+  return result;
 }
 
-+ (GRPCChannel *)insecureChannelWithHost:(NSString *)host channelArgs:(NSDictionary *)channelArgs {
-  return [[GRPCChannel alloc] initWithHost:host secure:NO credentials:NULL channelArgs:channelArgs];
+@end
+
+@implementation GRPCChannel {
+  GRPCChannelConfiguration *_configuration;
+
+  grpc_channel *_unmanagedChannel;
 }
 
-- (grpc_call *)unmanagedCallWithPath:(NSString *)path
-                          serverName:(NSString *)serverName
-                             timeout:(NSTimeInterval)timeout
-                     completionQueue:(GRPCCompletionQueue *)queue {
-  GPR_ASSERT(timeout >= 0);
-  if (timeout < 0) {
-    timeout = 0;
+- (instancetype)initWithChannelConfiguration:(GRPCChannelConfiguration *)channelConfiguration {
+  NSAssert(channelConfiguration != nil, @"channelConfiguration must not be empty.");
+  if (channelConfiguration == nil) {
+    return nil;
   }
-  grpc_slice host_slice = grpc_empty_slice();
-  if (serverName) {
-    host_slice = grpc_slice_from_copied_string(serverName.UTF8String);
+
+  if ((self = [super init])) {
+    _configuration = [channelConfiguration copy];
+
+    // Create gRPC core channel object.
+    NSString *host = channelConfiguration.host;
+    NSAssert(host.length != 0, @"host cannot be nil");
+    NSDictionary *channelArgs;
+    if (channelConfiguration.callOptions.additionalChannelArgs.count != 0) {
+      NSMutableDictionary *args = [channelConfiguration.channelArgs mutableCopy];
+      [args addEntriesFromDictionary:channelConfiguration.callOptions.additionalChannelArgs];
+      channelArgs = args;
+    } else {
+      channelArgs = channelConfiguration.channelArgs;
+    }
+    id<GRPCChannelFactory> factory = channelConfiguration.channelFactory;
+    _unmanagedChannel = [factory createChannelWithHost:host channelArgs:channelArgs];
+    NSAssert(_unmanagedChannel != NULL, @"Failed to create channel");
+    if (_unmanagedChannel == NULL) {
+      NSLog(@"Unable to create channel.");
+      return nil;
+    }
   }
+  return self;
+}
+
+- (grpc_call *)unmanagedCallWithPath:(NSString *)path
+                     completionQueue:(GRPCCompletionQueue *)queue
+                         callOptions:(GRPCCallOptions *)callOptions {
+  NSAssert(path.length > 0, @"path must not be empty.");
+  NSAssert(queue != nil, @"completionQueue must not be empty.");
+  NSAssert(callOptions != nil, @"callOptions must not be empty.");
+  if (path.length == 0) return NULL;
+  if (queue == nil) return NULL;
+  if (callOptions == nil) return NULL;
+
+  grpc_call *call = NULL;
+  // No need to lock here since _unmanagedChannel is only changed in _dealloc
+  NSAssert(_unmanagedChannel != NULL, @"Channel should have valid unmanaged channel.");
+  if (_unmanagedChannel == NULL) return NULL;
+
+  NSString *serverAuthority =
+      callOptions.transportType == GRPCTransportTypeCronet ? nil : callOptions.serverAuthority;
+  NSTimeInterval timeout = callOptions.timeout;
+  NSAssert(timeout >= 0, @"Invalid timeout");
+  if (timeout < 0) return NULL;
+  grpc_slice host_slice = serverAuthority
+                              ? grpc_slice_from_copied_string(serverAuthority.UTF8String)
+                              : grpc_empty_slice();
   grpc_slice path_slice = grpc_slice_from_copied_string(path.UTF8String);
   gpr_timespec deadline_ms =
       timeout == 0 ? gpr_inf_future(GPR_CLOCK_REALTIME)
                    : gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
                                   gpr_time_from_millis((int64_t)(timeout * 1000), GPR_TIMESPAN));
-  grpc_call *call = grpc_channel_create_call(_unmanagedChannel, NULL, GRPC_PROPAGATE_DEFAULTS,
-                                             queue.unmanagedQueue, path_slice,
-                                             serverName ? &host_slice : NULL, deadline_ms, NULL);
-  if (serverName) {
+  call = grpc_channel_create_call(_unmanagedChannel, NULL, GRPC_PROPAGATE_DEFAULTS,
+                                  queue.unmanagedQueue, path_slice,
+                                  serverAuthority ? &host_slice : NULL, deadline_ms, NULL);
+  if (serverAuthority) {
     grpc_slice_unref(host_slice);
   }
   grpc_slice_unref(path_slice);
+  NSAssert(call != nil, @"Unable to create call.");
+  if (call == NULL) {
+    NSLog(@"Unable to create call.");
+  }
   return call;
 }
 
+- (void)dealloc {
+  if (_unmanagedChannel) {
+    grpc_channel_destroy(_unmanagedChannel);
+  }
+}
+
 @end