Fix lock behavior on RTCAudioSession.

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"
 
 #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;
 
 // 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 _isLocked;
 }
 
 @synthesize session = _session;
-@synthesize lock = _lock;
 
 + (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];
-    _lock = [[NSRecursiveLock alloc] init];
+
     NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
     [center addObserver:self
                selector:@selector(handleInterruptionNotification:)
                    name:AVAudioSessionInterruptionNotification
                  object:nil];
     [center addObserver:self
                selector:@selector(handleRouteChangeNotification:)
                    name:AVAudioSessionRouteChangeNotification
                  object:nil];
     // TODO(tkchin): Maybe listen to SilenceSecondaryAudioHintNotification.
@@ skipping 20 matching lines @@
 }
 
 - (BOOL)isActive {
   @synchronized(self) {
     return _isActive;
   }
 }
 
 - (BOOL)isLocked {
   @synchronized(self) {
-    return _isLocked;
+    return _lockRecursionCount > 0;
   }
 }
 
 - (void)addDelegate:(id<RTCAudioSessionDelegate>)delegate {
   @synchronized(self) {
     [_delegates addObject:delegate];
   }
 }
 
 - (void)removeDelegate:(id<RTCAudioSessionDelegate>)delegate {
   @synchronized(self) {
     [_delegates removeObject:delegate];
   }
 }
 
 - (void)lockForConfiguration {
-  [_lock lock];
+  _crit.Enter();
   @synchronized(self) {
-    _isLocked = YES;
+    ++_lockRecursionCount;
   }
 }
 
 - (void)unlockForConfiguration {
   // Don't let threads other than the one that called lockForConfiguration
   // unlock.
-  if ([_lock tryLock]) {
+  if (_crit.TryEnter()) {
     @synchronized(self) {
-      _isLocked = NO;
+      --_lockRecursionCount;
     }
     // One unlock for the tryLock, and another one to actually unlock. If this
-    // was called without anyone calling lock, the underlying NSRecursiveLock
-    // should spit out an error.
-    [_lock unlock];
-    [_lock unlock];
+    // was called without anyone calling lock, we will hit an assertion.
+    _crit.Leave();
+    _crit.Leave();
   }
 }
 
 #pragma mark - AVAudioSession proxy methods
 
 - (NSString *)category {
   return self.session.category;
 }
 
 - (AVAudioSessionCategoryOptions)categoryOptions {
@@ skipping 390 matching lines @@
   }
 }
 
 - (void)notifyMediaServicesWereReset {
   for (id<RTCAudioSessionDelegate> delegate in self.delegates) {
     [delegate audioSessionMediaServicesWereReset:self];
   }
 }
 
 @end