Revert "GULLogger - issue count synchronous getters (#2610)"

This reverts commit c6da7d6.

Author: maksymmalyhin

GoogleUtilities/Example/Tests/Logger/GULLoggerTest.m

@@ -32,15 +32,15 @@
 
 extern BOOL getGULLoggerDebugMode(void);
 
-extern CFStringRef getGULLoggerUsetDefaultsSuiteName(void);
-extern dispatch_queue_t getGULLoggerCounterQueue(void);
+extern NSUserDefaults *getGULLoggerUsetDefaults(void);
 
 static NSString *const kMessageCode = @"I-COR000001";
 
 @interface GULLoggerTest : XCTestCase
 
 @property(nonatomic) NSString *randomLogString;
-@property(nonatomic) NSUserDefaults *loggerDefaults;
+
+@property(nonatomic, strong) NSUserDefaults *defaults;
 
 @end
 
@@ -50,18 +50,14 @@ - (void)setUp {
   [super setUp];
   GULResetLogger();
 
-  self.loggerDefaults = [[NSUserDefaults alloc]
-      initWithSuiteName:CFBridgingRelease(getGULLoggerUsetDefaultsSuiteName())];
+  // Stub NSUserDefaults for cleaner testing.
+  _defaults = [[NSUserDefaults alloc] initWithSuiteName:@"com.google.logger_test"];
 }
 
 - (void)tearDown {
-  // Make sure all async operations have finished before starting a new test.
-  [self drainQueue:getGULClientQueue()];
-  [self drainQueue:getGULLoggerCounterQueue()];
-
-  self.loggerDefaults = nil;
-
   [super tearDown];
+
+  _defaults = nil;
 }
 
 - (void)testMessageCodeFormat {
@@ -162,58 +158,93 @@ - (void)testGULLoggerLevelValues {
 - (void)testGetErrorWarningNumberBeforeLogDontCrash {
   GULResetLogger();
 
-  XCTAssertNoThrow(GULNumberOfErrorsLogged());
-  XCTAssertNoThrow(GULNumberOfWarningsLogged());
+  XCTestExpectation *getErrorCountExpectation =
+      [self expectationWithDescription:@"getErrorCountExpectation"];
+  XCTestExpectation *getWarningsCountExpectation =
+      [self expectationWithDescription:@"getWarningsCountExpectation"];
+
+  GULNumberOfErrorsLogged(^(NSInteger count) {
+    [getErrorCountExpectation fulfill];
+  });
+
+  GULNumberOfWarningsLogged(^(NSInteger count) {
+    [getWarningsCountExpectation fulfill];
+  });
+
+  [self waitForExpectations:@[ getErrorCountExpectation, getWarningsCountExpectation ]
+                    timeout:0.5
+               enforceOrder:YES];
 }
 
 - (void)testErrorNumberIncrement {
-  [self.loggerDefaults setInteger:10 forKey:kGULLoggerErrorCountKey];
+  [getGULLoggerUsetDefaults() setInteger:10 forKey:kGULLoggerErrorCountKey];
 
   GULLogError(@"my service", NO, kMessageCode, @"Message.");
 
-  [self drainQueue:getGULLoggerCounterQueue()];
-  XCTAssertEqual(GULNumberOfErrorsLogged(), 11);
+  XCTestExpectation *getErrorCountExpectation =
+      [self expectationWithDescription:@"getErrorCountExpectation"];
+
+  GULNumberOfErrorsLogged(^(NSInteger count) {
+    [getErrorCountExpectation fulfill];
+    XCTAssertEqual(count, 11);
+  });
+
+  [self waitForExpectationsWithTimeout:0.5 handler:NULL];
 }
 
 - (void)testWarningNumberIncrement {
-  [self.loggerDefaults setInteger:5 forKey:kGULLoggerWarningCountKey];
+  [getGULLoggerUsetDefaults() setInteger:5 forKey:kGULLoggerWarningCountKey];
 
   GULLogWarning(@"my service", NO, kMessageCode, @"Message.");
 
-  [self drainQueue:getGULLoggerCounterQueue()];
-  XCTAssertEqual(GULNumberOfWarningsLogged(), 6);
+  XCTestExpectation *getWarningsCountExpectation =
+      [self expectationWithDescription:@"getWarningsCountExpectation"];
+
+  GULNumberOfWarningsLogged(^(NSInteger count) {
+    [getWarningsCountExpectation fulfill];
+    XCTAssertEqual(count, 6);
+  });
+
+  [self waitForExpectationsWithTimeout:0.5 handler:NULL];
 }
 
 - (void)testResetIssuesCount {
-  [self.loggerDefaults setInteger:3 forKey:kGULLoggerErrorCountKey];
-  [self.loggerDefaults setInteger:4 forKey:kGULLoggerWarningCountKey];
+  [getGULLoggerUsetDefaults() setInteger:3 forKey:kGULLoggerErrorCountKey];
+  [getGULLoggerUsetDefaults() setInteger:4 forKey:kGULLoggerWarningCountKey];
 
   GULResetNumberOfIssuesLogged();
 
-  XCTAssertEqual(GULNumberOfErrorsLogged(), 0);
-  XCTAssertEqual(GULNumberOfWarningsLogged(), 0);
-}
+  XCTestExpectation *getErrorCountExpectation =
+      [self expectationWithDescription:@"getErrorCountExpectation"];
+  XCTestExpectation *getWarningsCountExpectation =
+      [self expectationWithDescription:@"getWarningsCountExpectation"];
+
+  GULNumberOfErrorsLogged(^(NSInteger count) {
+    [getErrorCountExpectation fulfill];
+    XCTAssertEqual(count, 0);
+  });
+
+  GULNumberOfWarningsLogged(^(NSInteger count) {
+    [getWarningsCountExpectation fulfill];
+    XCTAssertEqual(count, 0);
+  });
 
-- (void)testNumberOfIssuesLoggedNoDeadlock {
-  [self dispatchSyncNestedDispatchCount:100
-                                  queue:getGULLoggerCounterQueue()
-                                  block:^{
-                                    XCTAssertNoThrow(GULNumberOfErrorsLogged());
-                                    XCTAssertNoThrow(GULNumberOfWarningsLogged());
-                                  }];
+  [self waitForExpectations:@[ getErrorCountExpectation, getWarningsCountExpectation ]
+                    timeout:0.5
+               enforceOrder:YES];
 }
 
 // Helper functions.
 - (BOOL)logExists {
-  [self drainQueue:getGULClientQueue()];
+  [self drainGULClientQueue];
   NSString *correctMsg =
       [NSString stringWithFormat:@"%@[%@] %@", @"my service", kMessageCode, self.randomLogString];
   return [self messageWasLogged:correctMsg];
 }
 
-- (void)drainQueue:(dispatch_queue_t)queue {
+- (void)drainGULClientQueue {
   dispatch_semaphore_t workerSemaphore = dispatch_semaphore_create(0);
-  dispatch_barrier_async(queue, ^{
+  dispatch_async(getGULClientQueue(), ^{
     dispatch_semaphore_signal(workerSemaphore);
   });
   dispatch_semaphore_wait(workerSemaphore, DISPATCH_TIME_FOREVER);
@@ -241,19 +272,5 @@ - (BOOL)messageWasLogged:(NSString *)message {
 #pragma clang pop
 }
 
-- (void)dispatchSyncNestedDispatchCount:(NSInteger)count
-                                  queue:(dispatch_queue_t)queue
-                                  block:(dispatch_block_t)block {
-  if (count < 0) {
-    return;
-  }
-
-  dispatch_sync(queue, ^{
-    [self dispatchSyncNestedDispatchCount:count - 1 queue:queue block:block];
-    block();
-    NSLog(@"%@, depth: %ld", NSStringFromSelector(_cmd), (long)count);
-  });
-}
-
 @end
 #endif

GoogleUtilities/Logger/GULLogger.m

@@ -203,79 +203,62 @@ void GULLogBasic(GULLoggerLevel level,
 
 #undef GUL_MAKE_LOGGER
 
-#pragma mark - User defaults
-
-// NSUserDefaults cannot be used due to a bug described in GULUserDefaults
-// GULUserDefaults cannot be used because GULLogger is a dependency for GULUserDefaults
-// We have to use C API deireclty here
-
-CFStringRef getGULLoggerUsetDefaultsSuiteName(void) {
-  return (__bridge CFStringRef) @"GoogleUtilities.Logger.GULLogger";
-}
-
-NSInteger GULGetUserDefaultsIntegerForKey(NSString *key) {
-  id value = (__bridge_transfer id)CFPreferencesCopyAppValue((__bridge CFStringRef)key,
-                                                             getGULLoggerUsetDefaultsSuiteName());
-  if (![value isKindOfClass:[NSNumber class]]) {
-    return 0;
-  }
+#pragma mark - Number of errors and warnings
 
-  return [(NSNumber *)value integerValue];
-}
+NSUserDefaults *getGULLoggerUsetDefaults(void) {
+  static NSUserDefaults *_userDefaults = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    _userDefaults = [[NSUserDefaults alloc] initWithSuiteName:@"GoogleUtilities.Logger.GULLogger"];
+  });
 
-void GULLoggerUserDefaultsSetIntegerForKey(NSInteger count, NSString *key) {
-  NSNumber *countNumber = @(count);
-  CFPreferencesSetAppValue((__bridge CFStringRef)key, (__bridge CFNumberRef)countNumber,
-                           getGULLoggerUsetDefaultsSuiteName());
-  CFPreferencesAppSynchronize(getGULLoggerUsetDefaultsSuiteName());
+  return _userDefaults;
 }
 
-#pragma mark - Number of errors and warnings
-
 dispatch_queue_t getGULLoggerCounterQueue(void) {
   static dispatch_queue_t queue;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    queue =
-        dispatch_queue_create("GoogleUtilities.GULLogger.counterQueue", DISPATCH_QUEUE_CONCURRENT);
+    queue = dispatch_queue_create("GoogleUtilities.GULLogger.counterQueue", DISPATCH_QUEUE_SERIAL);
     dispatch_set_target_queue(queue,
                               dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0));
   });
 
   return queue;
 }
 
-NSInteger GULSyncGetUserDefaultsIntegerForKey(NSString *key) {
-  __block NSInteger integerValue = 0;
-  dispatch_sync(getGULLoggerCounterQueue(), ^{
-    integerValue = GULGetUserDefaultsIntegerForKey(key);
+void GULAsyncGetUserDefaultsIntegerForKey(NSString *key, void (^completion)(NSInteger)) {
+  dispatch_async(getGULLoggerCounterQueue(), ^{
+    NSInteger count = [getGULLoggerUsetDefaults() integerForKey:key];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      completion(count);
+    });
   });
-
-  return integerValue;
 }
 
-NSInteger GULNumberOfErrorsLogged(void) {
-  return GULSyncGetUserDefaultsIntegerForKey(kGULLoggerErrorCountKey);
+void GULNumberOfErrorsLogged(void (^completion)(NSInteger)) {
+  GULAsyncGetUserDefaultsIntegerForKey(kGULLoggerErrorCountKey, completion);
 }
 
-NSInteger GULNumberOfWarningsLogged(void) {
-  return GULSyncGetUserDefaultsIntegerForKey(kGULLoggerWarningCountKey);
+void GULNumberOfWarningsLogged(void (^completion)(NSInteger)) {
+  GULAsyncGetUserDefaultsIntegerForKey(kGULLoggerWarningCountKey, completion);
 }
 
 void GULResetNumberOfIssuesLogged(void) {
-  dispatch_barrier_async(getGULLoggerCounterQueue(), ^{
-    GULLoggerUserDefaultsSetIntegerForKey(0, kGULLoggerErrorCountKey);
-    GULLoggerUserDefaultsSetIntegerForKey(0, kGULLoggerWarningCountKey);
+  dispatch_async(getGULLoggerCounterQueue(), ^{
+    [getGULLoggerUsetDefaults() setInteger:0 forKey:kGULLoggerErrorCountKey];
+    [getGULLoggerUsetDefaults() setInteger:0 forKey:kGULLoggerWarningCountKey];
   });
 }
 
 void GULIncrementUserDefaultsIntegerForKey(NSString *key) {
-  NSInteger value = GULGetUserDefaultsIntegerForKey(key);
-  GULLoggerUserDefaultsSetIntegerForKey(value + 1, key);
+  NSUserDefaults *defaults = getGULLoggerUsetDefaults();
+  NSInteger errorCount = [defaults integerForKey:key];
+  [defaults setInteger:errorCount + 1 forKey:key];
 }
 
 void GULIncrementLogCountForLevel(GULLoggerLevel level) {
-  dispatch_barrier_async(getGULLoggerCounterQueue(), ^{
+  dispatch_async(getGULLoggerCounterQueue(), ^{
     if (level == GULLoggerLevelError) {
       GULIncrementUserDefaultsIntegerForKey(kGULLoggerErrorCountKey);
     } else if (level == GULLoggerLevelWarning) {

GoogleUtilities/Logger/Private/GULLogger.h

@@ -141,15 +141,13 @@ extern void GULLogDebug(GULLoggerService service,
 
 /**
  * Retrieve the number of errors that have been logged since the stat was last reset.
- * Calling this method can be comparably expensive, so it should not be called from main thread.
  */
-extern NSInteger GULNumberOfErrorsLogged(void);
+extern void GULNumberOfErrorsLogged(void (^completion)(NSInteger));
 
 /**
  * Retrieve the number of warnings that have been logged since the stat was last reset.
- * Calling this method can be comparably expensive, so it should not be called from main thread.
  */
-extern NSInteger GULNumberOfWarningsLogged(void);
+extern void GULNumberOfWarningsLogged(void (^completion)(NSInteger));
 
 /**
  * Reset number of errors and warnings that have been logged to 0.