Use RTCAudioSessionDelegate in AudioDeviceIOS.

webrtc/modules/audio_device/ios/objc/RTCAudioSession.mm

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
+#include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 
 #import "webrtc/base/objc/RTCLogging.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession+Private.h"
 
 NSString * const kRTCAudioSessionErrorDomain = @"org.webrtc.RTCAudioSession";
 NSInteger const kRTCAudioSessionErrorLockRequired = -1;
 NSInteger const kRTCAudioSessionErrorConfiguration = -2;
 
 // This class needs to be thread-safe because it is accessed from many threads.
 // TODO(tkchin): Consider more granular locking. We're not expecting a lot of
 // lock contention so coarse locks should be fine for now.
 @implementation RTCAudioSession {
   rtc::CriticalSection _crit;
   AVAudioSession *_session;
-  NSHashTable *_delegates;
   NSInteger _activationCount;
   NSInteger _lockRecursionCount;
   BOOL _isActive;
   BOOL _shouldDelayAudioConfiguration;
 }
 
 @synthesize session = _session;
+@synthesize delegates = _delegates;
 
 + (instancetype)sharedInstance {
   static dispatch_once_t onceToken;
   static RTCAudioSession *sharedInstance = nil;
   dispatch_once(&onceToken, ^{
     sharedInstance = [[RTCAudioSession alloc] init];
   });
   return sharedInstance;
 }
 
 - (instancetype)init {
   if (self = [super init]) {
     _session = [AVAudioSession sharedInstance];
-    _delegates = [NSHashTable weakObjectsHashTable];
 
     NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
     [center addObserver:self
                selector:@selector(handleInterruptionNotification:)
                    name:AVAudioSessionInterruptionNotification
                  object:nil];
     [center addObserver:self
                selector:@selector(handleRouteChangeNotification:)
                    name:AVAudioSessionRouteChangeNotification
                  object:nil];
@@ skipping 41 matching lines @@
   }
 }
 
 - (BOOL)shouldDelayAudioConfiguration {
   @synchronized(self) {
     return _shouldDelayAudioConfiguration;
   }
 }
 
 - (void)addDelegate:(id<RTCAudioSessionDelegate>)delegate {
+  if (!delegate) {
+    return;
+  }
   @synchronized(self) {
-    [_delegates addObject:delegate];
+    _delegates.push_back(delegate);
+    [self removeZeroedDelegates];
   }
 }
 
 - (void)removeDelegate:(id<RTCAudioSessionDelegate>)delegate {
+  if (!delegate) {
+    return;
+  }
   @synchronized(self) {
-    [_delegates removeObject:delegate];
+    _delegates.erase(std::remove(_delegates.begin(),
+                                 _delegates.end(),
+                                 delegate));
+    [self removeZeroedDelegates];
   }
 }
 
 - (void)lockForConfiguration {
   _crit.Enter();
   @synchronized(self) {
     ++_lockRecursionCount;
   }
 }
 
@@ skipping 90 matching lines @@
 }
 
 - (NSTimeInterval)outputLatency {
   return self.session.outputLatency;
 }
 
 - (NSTimeInterval)IOBufferDuration {
   return self.session.IOBufferDuration;
 }
 
+// TODO(tkchin): Simplify the amount of locking happening here. Likely that we
+// can just do atomic increments / decrements.
 - (BOOL)setActive:(BOOL)active
             error:(NSError **)outError {
   if (![self checkLock:outError]) {
     return NO;
   }
   NSInteger activationCount = self.activationCount;
   if (!active && activationCount == 0) {
     RTCLogWarning(@"Attempting to deactivate without prior activation.");
   }
   BOOL success = YES;
@@ skipping 212 matching lines @@
     NSLocalizedDescriptionKey:
         @"Must call lockForConfiguration before calling this method."
   };
   NSError *error =
       [[NSError alloc] initWithDomain:kRTCAudioSessionErrorDomain
                                  code:kRTCAudioSessionErrorLockRequired
                              userInfo:userInfo];
   return error;
 }
 
-- (NSSet *)delegates {
+- (std::vector<__weak id<RTCAudioSessionDelegate> >)delegates {
   @synchronized(self) {
-    return _delegates.setRepresentation;
+    // Note: this returns a copy.
+    return _delegates;
   }
 }
 
+- (void)pushDelegate:(id<RTCAudioSessionDelegate>)delegate {
+  @synchronized(self) {
+    _delegates.insert(_delegates.begin(), delegate);
+  }
+}
+
+- (void)removeZeroedDelegates {
+  @synchronized(self) {
+    for (auto it = _delegates.begin(); it != _delegates.end(); ++it) {
+      if (!*it) {
+        _delegates.erase(it);
+      }
+    }
+  }
+}
+
 - (NSInteger)activationCount {
   @synchronized(self) {
     return _activationCount;
   }
 }
 
 - (NSInteger)incrementActivationCount {
   RTCLog(@"Incrementing activation count.");
   @synchronized(self) {
     return ++_activationCount;
@@ skipping 28 matching lines @@
                   withOptions:options
                         error:&error]) {
     self.isActive = shouldActivate;
   } else {
     RTCLogError(@"Failed to set session active to %d. Error:%@",
                 shouldActivate, error.localizedDescription);
   }
 }
 
 - (void)notifyDidBeginInterruption {
-  for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
+  for (auto delegate : self.delegates) {
     [delegate audioSessionDidBeginInterruption:self];
   }
 }
 
 - (void)notifyDidEndInterruptionWithShouldResumeSession:
     (BOOL)shouldResumeSession {
-  for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
+  for (auto delegate : self.delegates) {
     [delegate audioSessionDidEndInterruption:self
                          shouldResumeSession:shouldResumeSession];
   }
 
 }
 
 - (void)notifyDidChangeRouteWithReason:(AVAudioSessionRouteChangeReason)reason
     previousRoute:(AVAudioSessionRouteDescription *)previousRoute {
-  for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
+  for (auto delegate : self.delegates) {
     [delegate audioSessionDidChangeRoute:self
                                   reason:reason
                            previousRoute:previousRoute];
   }
 }
 
 - (void)notifyMediaServicesWereLost {
-  for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
+  for (auto delegate : self.delegates) {
     [delegate audioSessionMediaServicesWereLost:self];
   }
 }
 
 - (void)notifyMediaServicesWereReset {
-  for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
+  for (auto delegate : self.delegates) {
     [delegate audioSessionMediaServicesWereReset:self];
   }
 }
 
 @end