Update to clang-format 12.0.1 (#8397)

Crashlytics/Shared/FIRCLSNetworking/FIRCLSFABNetworkClient.m

@@ -134,20 +134,18 @@ const NSUInteger FIRCLSNetworkMaximumRetryCount = 10;
                                   }
 
                                   [self
-                                      runAfterRetryValueFromResponse:response
-                                                            attempts:tries
-                                                               block:^{
-                                                                 [self
-                                                                     startDataTaskWithRequest:
-                                                                         request
-                                                                                   retryLimit:
-                                                                                       retryLimit
-                                                                                        tries:
-                                                                                            (tries +
+                                    runAfterRetryValueFromResponse:response
+                                                          attempts:tries
+                                                             block:^{
+                                                               [self
+                                                                   startDataTaskWithRequest:request
+                                                                                 retryLimit:
+                                                                                     retryLimit
+                                                                                      tries:(tries +
                                                                                              1)
-                                                                            completionHandler:
-                                                                                completionHandler];
-                                                               }];
+                                                                          completionHandler:
+                                                                              completionHandler];
+                                                             }];
                                 }];
         }];
 
@@ -211,20 +209,20 @@ const NSUInteger FIRCLSNetworkMaximumRetryCount = 10;
                                       }
 
                                       [self
-                                          runAfterRetryValueFromResponse:response
-                                                                attempts:tries
-                                                                   block:^{
-                                                                     [self
-                                                                         startDownloadTaskWithRequest:
-                                                                             request
-                                                                                           retryLimit:
-                                                                                               retryLimit
-                                                                                                tries:
-                                                                                                    (tries +
-                                                                                                     1)
-                                                                                    completionHandler:
-                                                                                        completionHandler];
-                                                                   }];
+                                        runAfterRetryValueFromResponse:response
+                                                              attempts:tries
+                                                                 block:^{
+                                                                   [self
+                                                                       startDownloadTaskWithRequest:
+                                                                           request
+                                                                                         retryLimit:
+                                                                                             retryLimit
+                                                                                              tries:
+                                                                                                  (tries +
+                                                                                                   1)
+                                                                                  completionHandler:
+                                                                                      completionHandler];
+                                                                 }];
                                     }];
             }];
 

FirebaseAppDistribution/Sources/FIRFADApiService.m

@@ -47,20 +47,20 @@ NSString *const kResponseReleasesKey = @"releases";
       return;
     }
 
-    [installations installationIDWithCompletion:^(NSString *__nullable identifier,
-                                                  NSError *__nullable error) {
-      if ([self handleError:&error
-                description:@"Failed to fetch Firebase Installation ID."
-                       code:FIRFADApiInstallationIdentifierError]) {
-        FIRFADErrorLog(@"Error getting installation id. Error: %@", [error localizedDescription]);
+    [installations
+      installationIDWithCompletion:^(NSString *__nullable identifier, NSError *__nullable error) {
+        if ([self handleError:&error
+                  description:@"Failed to fetch Firebase Installation ID."
+                         code:FIRFADApiInstallationIdentifierError]) {
+          FIRFADErrorLog(@"Error getting installation id. Error: %@", [error localizedDescription]);
 
-        completion(nil, nil, error);
+          completion(nil, nil, error);
 
-        return;
-      }
+          return;
+        }
 
-      completion(identifier, authTokenResult, nil);
-    }];
+        completion(identifier, authTokenResult, nil);
+      }];
   }];
 }
 

FirebaseAuth/Sources/Auth/FIRAuth.m

@@ -597,9 +597,9 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                                    return;
                                  }
                                  [self
-                                     internalSignInAndRetrieveDataWithCredential:credential
-                                                              isReauthentication:NO
-                                                                        callback:decoratedCallback];
+                                   internalSignInAndRetrieveDataWithCredential:credential
+                                                            isReauthentication:NO
+                                                                      callback:decoratedCallback];
                                }];
   });
 #endif  // TARGET_OS_IOS
@@ -678,18 +678,18 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
     return;
   }
   [FIRAuthBackend
-      verifyPassword:request
-            callback:^(FIRVerifyPasswordResponse *_Nullable response, NSError *_Nullable error) {
-              if (error) {
-                callback(nil, error);
-                return;
-              }
-              [self completeSignInWithAccessToken:response.IDToken
-                        accessTokenExpirationDate:response.approximateExpirationDate
-                                     refreshToken:response.refreshToken
-                                        anonymous:NO
-                                         callback:callback];
-            }];
+    verifyPassword:request
+          callback:^(FIRVerifyPasswordResponse *_Nullable response, NSError *_Nullable error) {
+            if (error) {
+              callback(nil, error);
+              return;
+            }
+            [self completeSignInWithAccessToken:response.IDToken
+                      accessTokenExpirationDate:response.approximateExpirationDate
+                                   refreshToken:response.refreshToken
+                                      anonymous:NO
+                                       callback:callback];
+          }];
 }
 
 /** @fn internalSignInAndRetrieveDataWithEmail:password:callback:
@@ -739,32 +739,31 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                     }
 
                     [self
-                        completeSignInWithAccessToken:response.IDToken
-                            accessTokenExpirationDate:response.approximateExpirationDate
-                                         refreshToken:response.refreshToken
-                                            anonymous:NO
-                                             callback:^(FIRUser *_Nullable user,
-                                                        NSError *_Nullable error) {
-                                               if (error && callback) {
-                                                 callback(nil, error);
-                                                 return;
-                                               }
-                                               FIRAdditionalUserInfo *additionalUserInfo =
-                                                   [[FIRAdditionalUserInfo alloc]
-                                                       initWithProviderID:
-                                                           FIRGameCenterAuthProviderID
-                                                                  profile:nil
-                                                                 username:nil
-                                                                isNewUser:response.isNewUser];
-                                               FIRAuthDataResult *result =
-                                                   user ? [[FIRAuthDataResult alloc]
-                                                                    initWithUser:user
-                                                              additionalUserInfo:additionalUserInfo]
-                                                        : nil;
-                                               if (callback) {
-                                                 callback(result, error);
-                                               }
-                                             }];
+                      completeSignInWithAccessToken:response.IDToken
+                          accessTokenExpirationDate:response.approximateExpirationDate
+                                       refreshToken:response.refreshToken
+                                          anonymous:NO
+                                           callback:^(FIRUser *_Nullable user,
+                                                      NSError *_Nullable error) {
+                                             if (error && callback) {
+                                               callback(nil, error);
+                                               return;
+                                             }
+                                             FIRAdditionalUserInfo *additionalUserInfo =
+                                                 [[FIRAdditionalUserInfo alloc]
+                                                     initWithProviderID:FIRGameCenterAuthProviderID
+                                                                profile:nil
+                                                               username:nil
+                                                              isNewUser:response.isNewUser];
+                                             FIRAuthDataResult *result =
+                                                 user ? [[FIRAuthDataResult alloc]
+                                                                  initWithUser:user
+                                                            additionalUserInfo:additionalUserInfo]
+                                                      : nil;
+                                             if (callback) {
+                                               callback(result, error);
+                                             }
+                                           }];
                   }];
 }
 
@@ -908,18 +907,17 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
     FIRPhoneAuthCredential *phoneCredential = (FIRPhoneAuthCredential *)credential;
     FIRAuthOperationType operation =
         isReauthentication ? FIRAuthOperationTypeReauth : FIRAuthOperationTypeSignUpOrSignIn;
-    [self
-        signInWithPhoneCredential:phoneCredential
-                        operation:operation
-                         callback:^(FIRVerifyPhoneNumberResponse *_Nullable response,
-                                    NSError *_Nullable error) {
-                           if (callback) {
-                             if (error) {
-                               callback(nil, error);
-                               return;
-                             }
-
-                             [self
+    [self signInWithPhoneCredential:phoneCredential
+                          operation:operation
+                           callback:^(FIRVerifyPhoneNumberResponse *_Nullable response,
+                                      NSError *_Nullable error) {
+                             if (callback) {
+                               if (error) {
+                                 callback(nil, error);
+                                 return;
+                               }
+
+                               [self
                                  completeSignInWithAccessToken:response.IDToken
                                      accessTokenExpirationDate:response.approximateExpirationDate
                                                   refreshToken:response.refreshToken
@@ -948,8 +946,8 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                                                           callback(result, error);
                                                         }
                                                       }];
-                           }
-                         }];
+                             }
+                           }];
     return;
   }
 #endif
@@ -989,33 +987,32 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                  return;
                }
                [self
-                   completeSignInWithAccessToken:response.IDToken
-                       accessTokenExpirationDate:response.approximateExpirationDate
-                                    refreshToken:response.refreshToken
-                                       anonymous:NO
-                                        callback:^(FIRUser *_Nullable user,
-                                                   NSError *_Nullable error) {
-                                          if (callback) {
-                                            if (error) {
-                                              callback(nil, error);
-                                              return;
-                                            }
-                                            FIRAdditionalUserInfo *additionalUserInfo =
-                                                [FIRAdditionalUserInfo
-                                                    userInfoWithVerifyAssertionResponse:response];
-                                            FIROAuthCredential *updatedOAuthCredential =
-                                                [[FIROAuthCredential alloc]
-                                                    initWithVerifyAssertionResponse:response];
-                                            FIRAuthDataResult *result =
-                                                user
-                                                    ? [[FIRAuthDataResult alloc]
-                                                                initWithUser:user
-                                                          additionalUserInfo:additionalUserInfo
-                                                                  credential:updatedOAuthCredential]
-                                                    : nil;
-                                            callback(result, error);
+                 completeSignInWithAccessToken:response.IDToken
+                     accessTokenExpirationDate:response.approximateExpirationDate
+                                  refreshToken:response.refreshToken
+                                     anonymous:NO
+                                      callback:^(FIRUser *_Nullable user,
+                                                 NSError *_Nullable error) {
+                                        if (callback) {
+                                          if (error) {
+                                            callback(nil, error);
+                                            return;
                                           }
-                                        }];
+                                          FIRAdditionalUserInfo *additionalUserInfo =
+                                              [FIRAdditionalUserInfo
+                                                  userInfoWithVerifyAssertionResponse:response];
+                                          FIROAuthCredential *updatedOAuthCredential =
+                                              [[FIROAuthCredential alloc]
+                                                  initWithVerifyAssertionResponse:response];
+                                          FIRAuthDataResult *result =
+                                              user ? [[FIRAuthDataResult alloc]
+                                                               initWithUser:user
+                                                         additionalUserInfo:additionalUserInfo
+                                                                 credential:updatedOAuthCredential]
+                                                   : nil;
+                                          callback(result, error);
+                                        }
+                                      }];
              }];
 }
 
@@ -1088,31 +1085,31 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                                return;
                              }
                              [self
-                                 completeSignInWithAccessToken:response.IDToken
-                                     accessTokenExpirationDate:response.approximateExpirationDate
-                                                  refreshToken:response.refreshToken
-                                                     anonymous:NO
-                                                      callback:^(FIRUser *_Nullable user,
-                                                                 NSError *_Nullable error) {
-                                                        if (error) {
-                                                          decoratedCallback(nil, error);
-                                                          return;
-                                                        }
-                                                        FIRAdditionalUserInfo *additionalUserInfo =
-                                                            [[FIRAdditionalUserInfo alloc]
-                                                                initWithProviderID:
-                                                                    FIREmailAuthProviderID
-                                                                           profile:nil
-                                                                          username:nil
-                                                                         isNewUser:YES];
-                                                        FIRAuthDataResult *authDataResult =
-                                                            user ? [[FIRAuthDataResult alloc]
-                                                                             initWithUser:user
-                                                                       additionalUserInfo:
-                                                                           additionalUserInfo]
-                                                                 : nil;
-                                                        decoratedCallback(authDataResult, error);
-                                                      }];
+                               completeSignInWithAccessToken:response.IDToken
+                                   accessTokenExpirationDate:response.approximateExpirationDate
+                                                refreshToken:response.refreshToken
+                                                   anonymous:NO
+                                                    callback:^(FIRUser *_Nullable user,
+                                                               NSError *_Nullable error) {
+                                                      if (error) {
+                                                        decoratedCallback(nil, error);
+                                                        return;
+                                                      }
+                                                      FIRAdditionalUserInfo *additionalUserInfo =
+                                                          [[FIRAdditionalUserInfo alloc]
+                                                              initWithProviderID:
+                                                                  FIREmailAuthProviderID
+                                                                         profile:nil
+                                                                        username:nil
+                                                                       isNewUser:YES];
+                                                      FIRAuthDataResult *authDataResult =
+                                                          user ? [[FIRAuthDataResult alloc]
+                                                                           initWithUser:user
+                                                                     additionalUserInfo:
+                                                                         additionalUserInfo]
+                                                               : nil;
+                                                      decoratedCallback(authDataResult, error);
+                                                    }];
                            }];
   });
 }
@@ -1838,9 +1835,9 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
                                                       rescheduleDelay = 60;
                                                     }
                                                     [strongSelf
-                                                        scheduleAutoTokenRefreshWithDelay:
-                                                            rescheduleDelay
-                                                                                    retry:YES];
+                                                      scheduleAutoTokenRefreshWithDelay:
+                                                          rescheduleDelay
+                                                                                  retry:YES];
                                                   }
                                                 }];
                     }];
@@ -2183,12 +2180,12 @@ static NSMutableDictionary *gKeychainServiceNameForAppName;
     }
     // Call back with current user token.
     [strongSelf->_currentUser
-        internalGetTokenForcingRefresh:forceRefresh
-                              callback:^(NSString *_Nullable token, NSError *_Nullable error) {
-                                dispatch_async(dispatch_get_main_queue(), ^{
-                                  callback(token, error);
-                                });
-                              }];
+      internalGetTokenForcingRefresh:forceRefresh
+                            callback:^(NSString *_Nullable token, NSError *_Nullable error) {
+                              dispatch_async(dispatch_get_main_queue(), ^{
+                                callback(token, error);
+                              });
+                            }];
   });
 }
 

FirebaseAuth/Sources/AuthProvider/GameCenter/FIRGameCenterAuthProvider.m

@@ -55,36 +55,36 @@ NS_ASSUME_NONNULL_BEGIN
     return;
   }
 
-  [localPlayer generateIdentityVerificationSignatureWithCompletionHandler:^(
-                   NSURL *publicKeyURL, NSData *signature, NSData *salt, uint64_t timestamp,
-                   NSError *error) {
-    if (error) {
-      if (completion) {
-        completion(nil, error);
-      }
-    } else {
-      if (completion) {
-        /**
-         @c `localPlayer.alias` is actually the displayname needed, instead of
-         `localPlayer.displayname`. For more information, check
-         https://developer.apple.com/documentation/gamekit/gkplayer
-         **/
-        NSString *displayName = localPlayer.alias;
+  [localPlayer
+    generateIdentityVerificationSignatureWithCompletionHandler:^(
+        NSURL *publicKeyURL, NSData *signature, NSData *salt, uint64_t timestamp, NSError *error) {
+      if (error) {
+        if (completion) {
+          completion(nil, error);
+        }
+      } else {
+        if (completion) {
+          /**
+           @c `localPlayer.alias` is actually the displayname needed, instead of
+           `localPlayer.displayname`. For more information, check
+           https://developer.apple.com/documentation/gamekit/gkplayer
+           **/
+          NSString *displayName = localPlayer.alias;
 // iOS 13 deprecation
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-        FIRGameCenterAuthCredential *credential =
-            [[FIRGameCenterAuthCredential alloc] initWithPlayerID:localPlayer.playerID
-                                                     publicKeyURL:publicKeyURL
-                                                        signature:signature
-                                                             salt:salt
-                                                        timestamp:timestamp
-                                                      displayName:displayName];
+          FIRGameCenterAuthCredential *credential =
+              [[FIRGameCenterAuthCredential alloc] initWithPlayerID:localPlayer.playerID
+                                                       publicKeyURL:publicKeyURL
+                                                          signature:signature
+                                                               salt:salt
+                                                          timestamp:timestamp
+                                                        displayName:displayName];
 #pragma clang diagnostic pop
-        completion(credential, nil);
+          completion(credential, nil);
+        }
       }
-    }
-  }];
+    }];
 }
 
 @end

FirebaseAuth/Sources/AuthProvider/Phone/FIRPhoneAuthProvider.m

@@ -305,22 +305,22 @@ extern NSString *const FIRPhoneMultiFactorID;
     return;
   }
   [_auth.notificationManager
-      checkNotificationForwardingWithCallback:^(BOOL isNotificationBeingForwarded) {
-        if (!isNotificationBeingForwarded) {
-          completion(nil, [FIRAuthErrorUtils notificationNotForwardedError]);
-          return;
-        }
-        FIRVerificationResultCallback callback =
-            ^(NSString *_Nullable verificationID, NSError *_Nullable error) {
-              if (completion) {
-                completion(verificationID, error);
-              }
-            };
-        [self verifyClientAndSendVerificationCodeToPhoneNumber:phoneNumber
-                                   retryOnInvalidAppCredential:YES
-                                                    UIDelegate:UIDelegate
-                                                      callback:callback];
-      }];
+    checkNotificationForwardingWithCallback:^(BOOL isNotificationBeingForwarded) {
+      if (!isNotificationBeingForwarded) {
+        completion(nil, [FIRAuthErrorUtils notificationNotForwardedError]);
+        return;
+      }
+      FIRVerificationResultCallback callback =
+          ^(NSString *_Nullable verificationID, NSError *_Nullable error) {
+            if (completion) {
+              completion(verificationID, error);
+            }
+          };
+      [self verifyClientAndSendVerificationCodeToPhoneNumber:phoneNumber
+                                 retryOnInvalidAppCredential:YES
+                                                  UIDelegate:UIDelegate
+                                                    callback:callback];
+    }];
 }
 
 - (void)internalVerifyPhoneNumber:(NSString *)phoneNumber
@@ -334,25 +334,25 @@ extern NSString *const FIRPhoneMultiFactorID;
     return;
   }
   [_auth.notificationManager
-      checkNotificationForwardingWithCallback:^(BOOL isNotificationBeingForwarded) {
-        if (!isNotificationBeingForwarded) {
-          if (completion) {
-            completion(nil, [FIRAuthErrorUtils notificationNotForwardedError]);
-          }
-          return;
+    checkNotificationForwardingWithCallback:^(BOOL isNotificationBeingForwarded) {
+      if (!isNotificationBeingForwarded) {
+        if (completion) {
+          completion(nil, [FIRAuthErrorUtils notificationNotForwardedError]);
         }
-        FIRVerificationResultCallback callback =
-            ^(NSString *_Nullable verificationID, NSError *_Nullable error) {
-              if (completion) {
-                completion(verificationID, error);
-              }
-            };
-        [self verifyClientAndSendVerificationCodeToPhoneNumber:phoneNumber
-                                   retryOnInvalidAppCredential:YES
-                                                    UIDelegate:UIDelegate
-                                            multiFactorSession:session
-                                                      callback:callback];
-      }];
+        return;
+      }
+      FIRVerificationResultCallback callback =
+          ^(NSString *_Nullable verificationID, NSError *_Nullable error) {
+            if (completion) {
+              completion(verificationID, error);
+            }
+          };
+      [self verifyClientAndSendVerificationCodeToPhoneNumber:phoneNumber
+                                 retryOnInvalidAppCredential:YES
+                                                  UIDelegate:UIDelegate
+                                          multiFactorSession:session
+                                                    callback:callback];
+    }];
 }
 
 /** @fn verifyClientAndSendVerificationCodeToPhoneNumber:retryOnInvalidAppCredential:callback:
@@ -381,66 +381,64 @@ extern NSString *const FIRPhoneMultiFactorID;
     return;
   }
   [self
-      verifyClientWithUIDelegate:UIDelegate
-                      completion:^(FIRAuthAppCredential *_Nullable appCredential,
-                                   NSString *_Nullable reCAPTCHAToken, NSError *_Nullable error) {
-                        if (error) {
-                          callback(nil, error);
-                          return;
-                        }
-                        FIRSendVerificationCodeRequest *_Nullable request;
-                        if (appCredential) {
-                          request = [[FIRSendVerificationCodeRequest alloc]
-                               initWithPhoneNumber:phoneNumber
-                                     appCredential:appCredential
-                                    reCAPTCHAToken:nil
-                              requestConfiguration:self->_auth.requestConfiguration];
-                        } else if (reCAPTCHAToken) {
-                          request = [[FIRSendVerificationCodeRequest alloc]
-                               initWithPhoneNumber:phoneNumber
-                                     appCredential:nil
-                                    reCAPTCHAToken:reCAPTCHAToken
-                              requestConfiguration:self->_auth.requestConfiguration];
-                        }
-                        if (request) {
-                          [FIRAuthBackend
-                              sendVerificationCode:request
-                                          callback:^(
-                                              FIRSendVerificationCodeResponse *_Nullable response,
-                                              NSError *_Nullable error) {
-                                            if (error) {
-                                              if (error.code ==
-                                                  FIRAuthErrorCodeInvalidAppCredential) {
-                                                if (retryOnInvalidAppCredential) {
-                                                  [self->_auth
-                                                          .appCredentialManager clearCredential];
-                                                  [self
-                                                      verifyClientAndSendVerificationCodeToPhoneNumber:
-                                                          phoneNumber
-                                                                           retryOnInvalidAppCredential:
-                                                                               NO
-                                                                                            UIDelegate:
-                                                                                                UIDelegate
-                                                                                              callback:
-                                                                                                  callback];
-                                                  return;
-                                                }
-                                                callback(
-                                                    nil,
-                                                    [FIRAuthErrorUtils
-                                                        unexpectedResponseWithDeserializedResponse:
-                                                            nil
-                                                                                   underlyingError:
-                                                                                       error]);
+    verifyClientWithUIDelegate:UIDelegate
+                    completion:^(FIRAuthAppCredential *_Nullable appCredential,
+                                 NSString *_Nullable reCAPTCHAToken, NSError *_Nullable error) {
+                      if (error) {
+                        callback(nil, error);
+                        return;
+                      }
+                      FIRSendVerificationCodeRequest *_Nullable request;
+                      if (appCredential) {
+                        request = [[FIRSendVerificationCodeRequest alloc]
+                             initWithPhoneNumber:phoneNumber
+                                   appCredential:appCredential
+                                  reCAPTCHAToken:nil
+                            requestConfiguration:self->_auth.requestConfiguration];
+                      } else if (reCAPTCHAToken) {
+                        request = [[FIRSendVerificationCodeRequest alloc]
+                             initWithPhoneNumber:phoneNumber
+                                   appCredential:nil
+                                  reCAPTCHAToken:reCAPTCHAToken
+                            requestConfiguration:self->_auth.requestConfiguration];
+                      }
+                      if (request) {
+                        [FIRAuthBackend
+                            sendVerificationCode:request
+                                        callback:^(
+                                            FIRSendVerificationCodeResponse *_Nullable response,
+                                            NSError *_Nullable error) {
+                                          if (error) {
+                                            if (error.code ==
+                                                FIRAuthErrorCodeInvalidAppCredential) {
+                                              if (retryOnInvalidAppCredential) {
+                                                [self->_auth.appCredentialManager clearCredential];
+                                                [self
+                                                    verifyClientAndSendVerificationCodeToPhoneNumber:
+                                                        phoneNumber
+                                                                         retryOnInvalidAppCredential:
+                                                                             NO
+                                                                                          UIDelegate:
+                                                                                              UIDelegate
+                                                                                            callback:
+                                                                                                callback];
                                                 return;
                                               }
-                                              callback(nil, error);
+                                              callback(
+                                                  nil,
+                                                  [FIRAuthErrorUtils
+                                                      unexpectedResponseWithDeserializedResponse:nil
+                                                                                 underlyingError:
+                                                                                     error]);
                                               return;
                                             }
-                                            callback(response.verificationID, nil);
-                                          }];
-                        }
-                      }];
+                                            callback(nil, error);
+                                            return;
+                                          }
+                                          callback(response.verificationID, nil);
+                                        }];
+                      }
+                    }];
 }
 
 - (void)verifyClientAndSendVerificationCodeToPhoneNumber:(NSString *)phoneNumber
@@ -463,128 +461,127 @@ extern NSString *const FIRPhoneMultiFactorID;
   }
 
   [self
-      verifyClientWithUIDelegate:UIDelegate
-                      completion:^(FIRAuthAppCredential *_Nullable appCredential,
-                                   NSString *_Nullable reCAPTCHAToken, NSError *_Nullable error) {
-                        if (error) {
-                          if (callback) {
-                            callback(nil, error);
-                          }
-                          return;
+    verifyClientWithUIDelegate:UIDelegate
+                    completion:^(FIRAuthAppCredential *_Nullable appCredential,
+                                 NSString *_Nullable reCAPTCHAToken, NSError *_Nullable error) {
+                      if (error) {
+                        if (callback) {
+                          callback(nil, error);
                         }
-
-                        NSString *IDToken = session.IDToken;
-                        FIRAuthProtoStartMFAPhoneRequestInfo *startMFARequestInfo =
-                            [[FIRAuthProtoStartMFAPhoneRequestInfo alloc]
-                                initWithPhoneNumber:phoneNumber
-                                      appCredential:appCredential
-                                     reCAPTCHAToken:reCAPTCHAToken];
-                        if (session.IDToken) {
-                          FIRStartMFAEnrollmentRequest *request =
-                              [[FIRStartMFAEnrollmentRequest alloc]
-                                       initWithIDToken:IDToken
-                                        enrollmentInfo:startMFARequestInfo
-                                  requestConfiguration:self->_auth.requestConfiguration];
-                          [FIRAuthBackend
-                              startMultiFactorEnrollment:request
-                                                callback:^(FIRStartMFAEnrollmentResponse
-                                                               *_Nullable response,
-                                                           NSError *_Nullable error) {
-                                                  if (error) {
-                                                    if (error.code ==
-                                                        FIRAuthErrorCodeInvalidAppCredential) {
-                                                      if (retryOnInvalidAppCredential) {
-                                                        [self->_auth.appCredentialManager
-                                                                clearCredential];
-                                                        [self
-                                                            verifyClientAndSendVerificationCodeToPhoneNumber:
-                                                                phoneNumber
-                                                                                 retryOnInvalidAppCredential:
-                                                                                     NO
-                                                                                                  UIDelegate:
-                                                                                                      UIDelegate
-                                                                                          multiFactorSession:
-                                                                                              session
-                                                                                                    callback:
-                                                                                                        callback];
-                                                        return;
-                                                      }
-                                                      if (callback) {
-                                                        callback(
-                                                            nil,
-                                                            [FIRAuthErrorUtils
-                                                                unexpectedResponseWithDeserializedResponse:
-                                                                    nil
-                                                                                           underlyingError:
-                                                                                               error]);
-                                                      }
+                        return;
+                      }
+
+                      NSString *IDToken = session.IDToken;
+                      FIRAuthProtoStartMFAPhoneRequestInfo *startMFARequestInfo =
+                          [[FIRAuthProtoStartMFAPhoneRequestInfo alloc]
+                              initWithPhoneNumber:phoneNumber
+                                    appCredential:appCredential
+                                   reCAPTCHAToken:reCAPTCHAToken];
+                      if (session.IDToken) {
+                        FIRStartMFAEnrollmentRequest *request =
+                            [[FIRStartMFAEnrollmentRequest alloc]
+                                     initWithIDToken:IDToken
+                                      enrollmentInfo:startMFARequestInfo
+                                requestConfiguration:self->_auth.requestConfiguration];
+                        [FIRAuthBackend
+                            startMultiFactorEnrollment:request
+                                              callback:^(
+                                                  FIRStartMFAEnrollmentResponse *_Nullable response,
+                                                  NSError *_Nullable error) {
+                                                if (error) {
+                                                  if (error.code ==
+                                                      FIRAuthErrorCodeInvalidAppCredential) {
+                                                    if (retryOnInvalidAppCredential) {
+                                                      [self->_auth.appCredentialManager
+                                                              clearCredential];
+                                                      [self
+                                                          verifyClientAndSendVerificationCodeToPhoneNumber:
+                                                              phoneNumber
+                                                                               retryOnInvalidAppCredential:
+                                                                                   NO
+                                                                                                UIDelegate:
+                                                                                                    UIDelegate
+                                                                                        multiFactorSession:
+                                                                                            session
+                                                                                                  callback:
+                                                                                                      callback];
                                                       return;
-                                                    } else {
-                                                      if (callback) {
-                                                        callback(nil, error);
-                                                      }
                                                     }
-                                                  } else {
                                                     if (callback) {
                                                       callback(
-                                                          response.enrollmentResponse.sessionInfo,
-                                                          nil);
+                                                          nil,
+                                                          [FIRAuthErrorUtils
+                                                              unexpectedResponseWithDeserializedResponse:
+                                                                  nil
+                                                                                         underlyingError:
+                                                                                             error]);
                                                     }
-                                                  }
-                                                }];
-                        } else {
-                          FIRStartMFASignInRequest *request = [[FIRStartMFASignInRequest alloc]
-                              initWithMFAPendingCredential:session.MFAPendingCredential
-                                           MFAEnrollmentID:session.multiFactorInfo.UID
-                                                signInInfo:startMFARequestInfo
-                                      requestConfiguration:self->_auth.requestConfiguration];
-                          [FIRAuthBackend
-                              startMultiFactorSignIn:request
-                                            callback:^(
-                                                FIRStartMFASignInResponse *_Nullable response,
-                                                NSError *_Nullable error) {
-                                              if (error) {
-                                                if (error.code ==
-                                                    FIRAuthErrorCodeInvalidAppCredential) {
-                                                  if (retryOnInvalidAppCredential) {
-                                                    [self->_auth
-                                                            .appCredentialManager clearCredential];
-                                                    [self
-                                                        verifyClientAndSendVerificationCodeToPhoneNumber:
-                                                            phoneNumber
-                                                                             retryOnInvalidAppCredential:
-                                                                                 NO
-                                                                                              UIDelegate:
-                                                                                                  UIDelegate
-                                                                                      multiFactorSession:
-                                                                                          session
-                                                                                                callback:
-                                                                                                    callback];
                                                     return;
+                                                  } else {
+                                                    if (callback) {
+                                                      callback(nil, error);
+                                                    }
                                                   }
+                                                } else {
                                                   if (callback) {
                                                     callback(
-                                                        nil,
-                                                        [FIRAuthErrorUtils
-                                                            unexpectedResponseWithDeserializedResponse:
-                                                                nil
-                                                                                       underlyingError:
-                                                                                           error]);
+                                                        response.enrollmentResponse.sessionInfo,
+                                                        nil);
                                                   }
+                                                }
+                                              }];
+                      } else {
+                        FIRStartMFASignInRequest *request = [[FIRStartMFASignInRequest alloc]
+                            initWithMFAPendingCredential:session.MFAPendingCredential
+                                         MFAEnrollmentID:session.multiFactorInfo.UID
+                                              signInInfo:startMFARequestInfo
+                                    requestConfiguration:self->_auth.requestConfiguration];
+                        [FIRAuthBackend
+                            startMultiFactorSignIn:request
+                                          callback:^(FIRStartMFASignInResponse *_Nullable response,
+                                                     NSError *_Nullable error) {
+                                            if (error) {
+                                              if (error.code ==
+                                                  FIRAuthErrorCodeInvalidAppCredential) {
+                                                if (retryOnInvalidAppCredential) {
+                                                  [self->_auth
+                                                          .appCredentialManager clearCredential];
+                                                  [self
+                                                      verifyClientAndSendVerificationCodeToPhoneNumber:
+                                                          phoneNumber
+                                                                           retryOnInvalidAppCredential:
+                                                                               NO
+                                                                                            UIDelegate:
+                                                                                                UIDelegate
+                                                                                    multiFactorSession:
+                                                                                        session
+                                                                                              callback:
+                                                                                                  callback];
                                                   return;
-                                                } else {
-                                                  if (callback) {
-                                                    callback(nil, error);
-                                                  }
                                                 }
+                                                if (callback) {
+                                                  callback(
+                                                      nil,
+                                                      [FIRAuthErrorUtils
+                                                          unexpectedResponseWithDeserializedResponse:
+                                                              nil
+                                                                                     underlyingError:
+                                                                                         error]);
+                                                }
+                                                return;
                                               } else {
                                                 if (callback) {
-                                                  callback(response.responseInfo.sessionInfo, nil);
+                                                  callback(nil, error);
                                                 }
                                               }
-                                            }];
-                        }
-                      }];
+                                            } else {
+                                              if (callback) {
+                                                callback(response.responseInfo.sessionInfo, nil);
+                                              }
+                                            }
+                                          }];
+                      }
+                    }];
 }
 
 /** @fn verifyClientWithCompletion:completion:

FirebaseAuth/Sources/Backend/FIRAuthBackend.m

@@ -1003,124 +1003,123 @@ static id<FIRAuthBackendImplementation> gBackendImplementation;
   }
 
   [_RPCIssuer
-      asyncPostToURLWithRequestConfiguration:[request requestConfiguration]
-                                         URL:[request requestURL]
-                                        body:bodyData
-                                 contentType:kJSONContentType
-                           completionHandler:^(NSData *data, NSError *error) {
-                             // If there is an error with no body data at all, then this must be a
-                             // network error.
-                             if (error && !data) {
-                               callback([FIRAuthErrorUtils networkErrorWithUnderlyingError:error]);
-                               return;
-                             }
-
-                             // Try to decode the HTTP response data which may contain either a
-                             // successful response or error message.
-                             NSError *jsonError;
-                             NSDictionary *dictionary =
-                                 [NSJSONSerialization JSONObjectWithData:data
-                                                                 options:NSJSONReadingMutableLeaves
-                                                                   error:&jsonError];
-                             if (!dictionary) {
-                               if (error) {
-                                 // We have an error, but we couldn't decode the body, so we have no
-                                 // additional information other than the raw response and the
-                                 // original NSError (the jsonError is infered by the error code
-                                 // (FIRAuthErrorCodeUnexpectedHTTPResponse, and is irrelevant.)
-                                 callback([FIRAuthErrorUtils
-                                     unexpectedErrorResponseWithData:data
-                                                     underlyingError:error]);
-                               } else {
-                                 // This is supposed to be a "successful" response, but we couldn't
-                                 // deserialize the body.
-                                 callback([FIRAuthErrorUtils unexpectedResponseWithData:data
-                                                                        underlyingError:jsonError]);
-                               }
-                               return;
-                             }
-                             if (![dictionary isKindOfClass:[NSDictionary class]]) {
-                               if (error) {
-                                 callback([FIRAuthErrorUtils
-                                     unexpectedErrorResponseWithDeserializedResponse:dictionary]);
-                               } else {
-                                 callback([FIRAuthErrorUtils
-                                     unexpectedResponseWithDeserializedResponse:dictionary]);
-                               }
-                               return;
+    asyncPostToURLWithRequestConfiguration:[request requestConfiguration]
+                                       URL:[request requestURL]
+                                      body:bodyData
+                               contentType:kJSONContentType
+                         completionHandler:^(NSData *data, NSError *error) {
+                           // If there is an error with no body data at all, then this must be a
+                           // network error.
+                           if (error && !data) {
+                             callback([FIRAuthErrorUtils networkErrorWithUnderlyingError:error]);
+                             return;
+                           }
+
+                           // Try to decode the HTTP response data which may contain either a
+                           // successful response or error message.
+                           NSError *jsonError;
+                           NSDictionary *dictionary =
+                               [NSJSONSerialization JSONObjectWithData:data
+                                                               options:NSJSONReadingMutableLeaves
+                                                                 error:&jsonError];
+                           if (!dictionary) {
+                             if (error) {
+                               // We have an error, but we couldn't decode the body, so we have no
+                               // additional information other than the raw response and the
+                               // original NSError (the jsonError is infered by the error code
+                               // (FIRAuthErrorCodeUnexpectedHTTPResponse, and is irrelevant.)
+                               callback([FIRAuthErrorUtils unexpectedErrorResponseWithData:data
+                                                                           underlyingError:error]);
+                             } else {
+                               // This is supposed to be a "successful" response, but we couldn't
+                               // deserialize the body.
+                               callback([FIRAuthErrorUtils unexpectedResponseWithData:data
+                                                                      underlyingError:jsonError]);
                              }
-
-                             // At this point we either have an error with successfully decoded
-                             // details in the body, or we have a response which must pass further
-                             // validation before we know it's truly successful. We deal with the
-                             // case where we have an error with successfully decoded error details
-                             // first:
+                             return;
+                           }
+                           if (![dictionary isKindOfClass:[NSDictionary class]]) {
                              if (error) {
-                               NSDictionary *errorDictionary = dictionary[kErrorKey];
-                               if ([errorDictionary isKindOfClass:[NSDictionary class]]) {
-                                 id<NSObject> errorMessage = errorDictionary[kErrorMessageKey];
-                                 if ([errorMessage isKindOfClass:[NSString class]]) {
-                                   NSString *errorMessageString = (NSString *)errorMessage;
-
-                                   // Contruct client error.
-                                   NSError *clientError = [[self class]
-                                       clientErrorWithServerErrorMessage:errorMessageString
-                                                         errorDictionary:errorDictionary
-                                                                response:response];
-                                   if (clientError) {
-                                     callback(clientError);
-                                     return;
-                                   }
-                                 }
-                                 // Not a message we know, return the message directly.
-                                 if (errorMessage) {
-                                   NSError *unexpecterErrorResponse = [FIRAuthErrorUtils
-                                       unexpectedErrorResponseWithDeserializedResponse:
-                                           errorDictionary];
-                                   callback(unexpecterErrorResponse);
-                                   return;
-                                 }
-                               }
-                               // No error message at all, return the decoded response.
                                callback([FIRAuthErrorUtils
                                    unexpectedErrorResponseWithDeserializedResponse:dictionary]);
-                               return;
-                             }
-
-                             // Finally, we try to populate the response object with the JSON
-                             // values.
-                             if (![response setWithDictionary:dictionary error:&error]) {
+                             } else {
                                callback([FIRAuthErrorUtils
-                                   RPCResponseDecodingErrorWithDeserializedResponse:dictionary
-                                                                    underlyingError:error]);
-                               return;
+                                   unexpectedResponseWithDeserializedResponse:dictionary]);
                              }
-                             // In case returnIDPCredential of a verifyAssertion request is set to
-                             // @YES, the server may return a 200 with a response that may contain a
-                             // server error.
-                             if ([request isKindOfClass:[FIRVerifyAssertionRequest class]]) {
-                               FIRVerifyAssertionRequest *verifyAssertionRequest =
-                                   (FIRVerifyAssertionRequest *)request;
-                               if (verifyAssertionRequest.returnIDPCredential) {
-                                 NSString *errorMessage =
-                                     dictionary[kReturnIDPCredentialErrorMessageKey];
-                                 if ([errorMessage isKindOfClass:[NSString class]]) {
-                                   NSString *errorString = (NSString *)errorMessage;
-                                   NSError *clientError =
-                                       [[self class] clientErrorWithServerErrorMessage:errorString
-                                                                       errorDictionary:@{}
-                                                                              response:response];
-                                   if (clientError) {
-                                     callback(clientError);
-                                     return;
-                                   }
+                             return;
+                           }
+
+                           // At this point we either have an error with successfully decoded
+                           // details in the body, or we have a response which must pass further
+                           // validation before we know it's truly successful. We deal with the
+                           // case where we have an error with successfully decoded error details
+                           // first:
+                           if (error) {
+                             NSDictionary *errorDictionary = dictionary[kErrorKey];
+                             if ([errorDictionary isKindOfClass:[NSDictionary class]]) {
+                               id<NSObject> errorMessage = errorDictionary[kErrorMessageKey];
+                               if ([errorMessage isKindOfClass:[NSString class]]) {
+                                 NSString *errorMessageString = (NSString *)errorMessage;
+
+                                 // Contruct client error.
+                                 NSError *clientError = [[self class]
+                                     clientErrorWithServerErrorMessage:errorMessageString
+                                                       errorDictionary:errorDictionary
+                                                              response:response];
+                                 if (clientError) {
+                                   callback(clientError);
+                                   return;
+                                 }
+                               }
+                               // Not a message we know, return the message directly.
+                               if (errorMessage) {
+                                 NSError *unexpecterErrorResponse = [FIRAuthErrorUtils
+                                     unexpectedErrorResponseWithDeserializedResponse:
+                                         errorDictionary];
+                                 callback(unexpecterErrorResponse);
+                                 return;
+                               }
+                             }
+                             // No error message at all, return the decoded response.
+                             callback([FIRAuthErrorUtils
+                                 unexpectedErrorResponseWithDeserializedResponse:dictionary]);
+                             return;
+                           }
+
+                           // Finally, we try to populate the response object with the JSON
+                           // values.
+                           if (![response setWithDictionary:dictionary error:&error]) {
+                             callback([FIRAuthErrorUtils
+                                 RPCResponseDecodingErrorWithDeserializedResponse:dictionary
+                                                                  underlyingError:error]);
+                             return;
+                           }
+                           // In case returnIDPCredential of a verifyAssertion request is set to
+                           // @YES, the server may return a 200 with a response that may contain a
+                           // server error.
+                           if ([request isKindOfClass:[FIRVerifyAssertionRequest class]]) {
+                             FIRVerifyAssertionRequest *verifyAssertionRequest =
+                                 (FIRVerifyAssertionRequest *)request;
+                             if (verifyAssertionRequest.returnIDPCredential) {
+                               NSString *errorMessage =
+                                   dictionary[kReturnIDPCredentialErrorMessageKey];
+                               if ([errorMessage isKindOfClass:[NSString class]]) {
+                                 NSString *errorString = (NSString *)errorMessage;
+                                 NSError *clientError =
+                                     [[self class] clientErrorWithServerErrorMessage:errorString
+                                                                     errorDictionary:@{}
+                                                                            response:response];
+                                 if (clientError) {
+                                   callback(clientError);
+                                   return;
                                  }
                                }
                              }
-                             // Success! The response object originally passed in can be used by the
-                             // caller.
-                             callback(nil);
-                           }];
+                           }
+                           // Success! The response object originally passed in can be used by the
+                           // caller.
+                           callback(nil);
+                         }];
 }
 
 /** @fn clientErrorWithServerErrorMessage:errorDictionary:

FirebaseAuth/Sources/SystemService/FIRSecureTokenService.m

@@ -185,25 +185,25 @@ static const NSTimeInterval kFiveMinutes = 5 * 60;
                                         requestConfiguration:_requestConfiguration];
   }
   [FIRAuthBackend
-      secureToken:request
-         callback:^(FIRSecureTokenResponse *_Nullable response, NSError *_Nullable error) {
-           BOOL tokenUpdated = NO;
-           NSString *newAccessToken = response.accessToken;
-           if (newAccessToken.length && ![newAccessToken isEqualToString:self->_accessToken]) {
-             self->_accessToken = [newAccessToken copy];
-             self->_accessTokenExpirationDate = response.approximateExpirationDate;
-             tokenUpdated = YES;
-             FIRLogDebug(kFIRLoggerAuth, @"I-AUT000017",
-                         @"Updated access token. Estimated expiration date: %@, current date: %@",
-                         self->_accessTokenExpirationDate, [NSDate date]);
-           }
-           NSString *newRefreshToken = response.refreshToken;
-           if (newRefreshToken.length && ![newRefreshToken isEqualToString:self->_refreshToken]) {
-             self->_refreshToken = [newRefreshToken copy];
-             tokenUpdated = YES;
-           }
-           callback(newAccessToken, error, tokenUpdated);
-         }];
+    secureToken:request
+       callback:^(FIRSecureTokenResponse *_Nullable response, NSError *_Nullable error) {
+         BOOL tokenUpdated = NO;
+         NSString *newAccessToken = response.accessToken;
+         if (newAccessToken.length && ![newAccessToken isEqualToString:self->_accessToken]) {
+           self->_accessToken = [newAccessToken copy];
+           self->_accessTokenExpirationDate = response.approximateExpirationDate;
+           tokenUpdated = YES;
+           FIRLogDebug(kFIRLoggerAuth, @"I-AUT000017",
+                       @"Updated access token. Estimated expiration date: %@, current date: %@",
+                       self->_accessTokenExpirationDate, [NSDate date]);
+         }
+         NSString *newRefreshToken = response.refreshToken;
+         if (newRefreshToken.length && ![newRefreshToken isEqualToString:self->_refreshToken]) {
+           self->_refreshToken = [newRefreshToken copy];
+           tokenUpdated = YES;
+         }
+         callback(newAccessToken, error, tokenUpdated);
+       }];
 }
 
 - (BOOL)hasValidAccessToken {

FirebaseAuth/Sources/User/FIRUser.m

@@ -488,47 +488,47 @@ static void callInMainThreadWithAuthDataResultAndError(
         callback(error);
         return;
       }
-      [self internalGetTokenWithCallback:^(NSString *_Nullable accessToken,
-                                           NSError *_Nullable error) {
-        if (error) {
-          complete();
-          callback(error);
-          return;
-        }
-        FIRAuthRequestConfiguration *configuration = self->_auth.requestConfiguration;
-        // Mutate setAccountInfoRequest in block:
-        FIRSetAccountInfoRequest *setAccountInfoRequest =
-            [[FIRSetAccountInfoRequest alloc] initWithRequestConfiguration:configuration];
-        setAccountInfoRequest.accessToken = accessToken;
-        changeBlock(user, setAccountInfoRequest);
-        // Execute request:
-        [FIRAuthBackend
-            setAccountInfo:setAccountInfoRequest
-                  callback:^(FIRSetAccountInfoResponse *_Nullable response,
-                             NSError *_Nullable error) {
-                    if (error) {
-                      [self signOutIfTokenIsInvalidWithError:error];
+      [self
+        internalGetTokenWithCallback:^(NSString *_Nullable accessToken, NSError *_Nullable error) {
+          if (error) {
+            complete();
+            callback(error);
+            return;
+          }
+          FIRAuthRequestConfiguration *configuration = self->_auth.requestConfiguration;
+          // Mutate setAccountInfoRequest in block:
+          FIRSetAccountInfoRequest *setAccountInfoRequest =
+              [[FIRSetAccountInfoRequest alloc] initWithRequestConfiguration:configuration];
+          setAccountInfoRequest.accessToken = accessToken;
+          changeBlock(user, setAccountInfoRequest);
+          // Execute request:
+          [FIRAuthBackend
+              setAccountInfo:setAccountInfoRequest
+                    callback:^(FIRSetAccountInfoResponse *_Nullable response,
+                               NSError *_Nullable error) {
+                      if (error) {
+                        [self signOutIfTokenIsInvalidWithError:error];
+                        complete();
+                        callback(error);
+                        return;
+                      }
+                      if (response.IDToken && response.refreshToken) {
+                        FIRSecureTokenService *tokenService = [[FIRSecureTokenService alloc]
+                            initWithRequestConfiguration:configuration
+                                             accessToken:response.IDToken
+                               accessTokenExpirationDate:response.approximateExpirationDate
+                                            refreshToken:response.refreshToken];
+                        [self setTokenService:tokenService
+                                     callback:^(NSError *_Nullable error) {
+                                       complete();
+                                       callback(error);
+                                     }];
+                        return;
+                      }
                       complete();
-                      callback(error);
-                      return;
-                    }
-                    if (response.IDToken && response.refreshToken) {
-                      FIRSecureTokenService *tokenService = [[FIRSecureTokenService alloc]
-                          initWithRequestConfiguration:configuration
-                                           accessToken:response.IDToken
-                             accessTokenExpirationDate:response.approximateExpirationDate
-                                          refreshToken:response.refreshToken];
-                      [self setTokenService:tokenService
-                                   callback:^(NSError *_Nullable error) {
-                                     complete();
-                                     callback(error);
-                                   }];
-                      return;
-                    }
-                    complete();
-                    callback(nil);
-                  }];
-      }];
+                      callback(nil);
+                    }];
+        }];
     }];
   }];
 }
@@ -824,11 +824,11 @@ static void callInMainThreadWithAuthDataResultAndError(
                                              }
                                              // Successful reauthenticate
                                              [self
-                                                 setTokenService:authResult.user->_tokenService
-                                                        callback:^(NSError *_Nullable error) {
-                                                          callInMainThreadWithAuthDataResultAndError(
-                                                              completion, authResult, error);
-                                                        }];
+                                               setTokenService:authResult.user->_tokenService
+                                                      callback:^(NSError *_Nullable error) {
+                                                        callInMainThreadWithAuthDataResultAndError(
+                                                            completion, authResult, error);
+                                                      }];
                                            }];
   });
 }

FirebaseCore/Sources/FIRApp.m

@@ -409,8 +409,8 @@ static FIRApp *sDefaultApp;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
   [[FIRAnalyticsConfiguration sharedInstance]
-      setAnalyticsCollectionEnabled:dataCollectionDefaultEnabled
-                     persistSetting:NO];
+    setAnalyticsCollectionEnabled:dataCollectionDefaultEnabled
+                   persistSetting:NO];
 #pragma clang diagnostic pop
 }
 

FirebaseDatabase/Sources/Api/Private/FTypedefs_Private.h

@@ -38,8 +38,8 @@ typedef NS_ENUM(NSInteger, FTransactionStatus) {
 typedef void (^fbt_void_nserror_bool_datasnapshot)(NSError *error,
                                                    BOOL committed,
                                                    FIRDataSnapshot *snapshot);
-typedef FIRTransactionResult * (
-    ^fbt_transactionresult_mutabledata)(FIRMutableData *currentData);
+typedef FIRTransactionResult * (^fbt_transactionresult_mutabledata)(
+    FIRMutableData *currentData);
 typedef void (^fbt_void_path_node)(FPath *, id<FNode>);
 typedef void (^fbt_void_nsstring)(NSString *);
 typedef BOOL (^fbt_bool_nsstring_node)(NSString *, id<FNode>);

FirebaseDatabase/Tests/Integration/FData.m

@@ -3199,10 +3199,10 @@ XCTAssertTrue([target isEqualTo:recvd], @"Expected %@ to match %@", target, recv
               }];
   }
   [self
-      waitUntil:^BOOL {
-        return done;
-      }
-        timeout:300];
+    waitUntil:^BOOL {
+      return done;
+    }
+      timeout:300];
   NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
   NSLog(@"Elapsed: %f", elapsed);
 }
@@ -3232,10 +3232,10 @@ XCTAssertTrue([target isEqualTo:recvd], @"Expected %@ to match %@", target, recv
                    }];
   }
   [self
-      waitUntil:^BOOL {
-        return done;
-      }
-        timeout:300];
+    waitUntil:^BOOL {
+      return done;
+    }
+      timeout:300];
 
   NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
   NSLog(@"Elapsed: %f", elapsed);
@@ -3269,10 +3269,10 @@ XCTAssertTrue([target isEqualTo:recvd], @"Expected %@ to match %@", target, recv
             }];
   }
   [self
-      waitUntil:^BOOL {
-        return done;
-      }
-        timeout:300];
+    waitUntil:^BOOL {
+      return done;
+    }
+      timeout:300];
 
   NSTimeInterval elapsed = [finished timeIntervalSinceDate:start];
   NSLog(@"Elapsed: %f", elapsed);

FirebaseDatabase/Tests/Integration/FOrder.m

@@ -31,17 +31,17 @@
   }
 
   [super
-      snapWaiter:node
-       withBlock:^(FIRDataSnapshot *snapshot) {
-         int expected = 0;
-         for (FIRDataSnapshot *child in snapshot.children) {
-           XCTAssertEqualObjects([NSNumber numberWithInt:expected], [child value],
-                                 @"Expects values match.");
-           expected = expected + 1;
-         }
-         XCTAssertTrue(expected == 10, @"Should get all of the children");
-         XCTAssertTrue(expected == snapshot.childrenCount, @"Snapshot should report correct count");
-       }];
+    snapWaiter:node
+     withBlock:^(FIRDataSnapshot *snapshot) {
+       int expected = 0;
+       for (FIRDataSnapshot *child in snapshot.children) {
+         XCTAssertEqualObjects([NSNumber numberWithInt:expected], [child value],
+                               @"Expects values match.");
+         expected = expected + 1;
+       }
+       XCTAssertTrue(expected == 10, @"Should get all of the children");
+       XCTAssertTrue(expected == snapshot.childrenCount, @"Snapshot should report correct count");
+     }];
 }
 
 - (void)testPushEnumerateManyPathsWriteAndCheckOrder {

FirebaseInAppMessaging/Sources/Flows/FIRIAMClientInfoFetcher.m

@@ -55,31 +55,31 @@
     return;
   }
 
-  [self.installations authTokenWithCompletion:^(
-                          FIRInstallationsAuthTokenResult *_Nullable tokenResult,
-                          NSError *_Nullable error) {
-    if (error) {
-      FIRLogWarning(kFIRLoggerInAppMessaging, @"I-IAM190006", @"Error in fetching FIS token: %@",
-                    error.localizedDescription);
-      completion(nil, nil, error);
-    } else {
-      FIRLogDebug(kFIRLoggerInAppMessaging, @"I-IAM190007", @"Successfully generated FIS token");
-
-      [self.installations
-          installationIDWithCompletion:^(NSString *_Nullable identifier, NSError *_Nullable error) {
-            if (error) {
-              FIRLogWarning(kFIRLoggerInAppMessaging, @"I-IAM190008", @"Error in fetching FID: %@",
-                            error.localizedDescription);
-              completion(nil, tokenResult.authToken, error);
-            } else {
-              FIRLogDebug(kFIRLoggerInAppMessaging, @"I-IAM190009",
-                          @"Successfully in fetching both FID as %@ and FIS token as %@",
-                          identifier, tokenResult.authToken);
-              completion(identifier, tokenResult.authToken, nil);
-            }
-          }];
-    }
-  }];
+  [self.installations
+    authTokenWithCompletion:^(FIRInstallationsAuthTokenResult *_Nullable tokenResult,
+                              NSError *_Nullable error) {
+      if (error) {
+        FIRLogWarning(kFIRLoggerInAppMessaging, @"I-IAM190006", @"Error in fetching FIS token: %@",
+                      error.localizedDescription);
+        completion(nil, nil, error);
+      } else {
+        FIRLogDebug(kFIRLoggerInAppMessaging, @"I-IAM190007", @"Successfully generated FIS token");
+
+        [self.installations installationIDWithCompletion:^(NSString *_Nullable identifier,
+                                                           NSError *_Nullable error) {
+          if (error) {
+            FIRLogWarning(kFIRLoggerInAppMessaging, @"I-IAM190008", @"Error in fetching FID: %@",
+                          error.localizedDescription);
+            completion(nil, tokenResult.authToken, error);
+          } else {
+            FIRLogDebug(kFIRLoggerInAppMessaging, @"I-IAM190009",
+                        @"Successfully in fetching both FID as %@ and FIS token as %@", identifier,
+                        tokenResult.authToken);
+            completion(identifier, tokenResult.authToken, nil);
+          }
+        }];
+      }
+    }];
 }
 
 - (nullable NSString *)getDeviceLanguageCode {

FirebaseInAppMessaging/Sources/Runtime/FIRIAMRuntimeManager.m

@@ -429,7 +429,7 @@ static NSString *const kFirebaseInAppMessagingAutoDataCollectionKey =
                                  // One-time triggering of checks for both fetch flow
                                  // upon SDK/app startup.
                                  [self.fetchOnAppForegroundFlow
-                                     checkAndFetchForInitialAppLaunch:YES];
+                                   checkAndFetchForInitialAppLaunch:YES];
                                } else {
                                  FIRLogDebug(kFIRLoggerInAppMessaging, @"I-IAM180009",
                                              @"No FIAM SDK startup due to settings.");

FirebaseMessaging/Sources/FIRMessaging.m

@@ -578,14 +578,14 @@ BOOL FIRMessagingIsContextManagerMessage(NSDictionary *message) {
                            senderID);
   }
   [self.tokenManager
-      tokenWithAuthorizedEntity:senderID
-                          scope:kFIRMessagingDefaultTokenScope
-                        options:options
-                        handler:^(NSString *_Nullable FCMToken, NSError *_Nullable error) {
-                          if (completion) {
-                            completion(FCMToken, error);
-                          }
-                        }];
+    tokenWithAuthorizedEntity:senderID
+                        scope:kFIRMessagingDefaultTokenScope
+                      options:options
+                      handler:^(NSString *_Nullable FCMToken, NSError *_Nullable error) {
+                        if (completion) {
+                          completion(FCMToken, error);
+                        }
+                      }];
 }
 
 - (void)deleteFCMTokenForSenderID:(nonnull NSString *)senderID

FirebaseMessaging/Sources/Token/FIRMessagingAuthService.m

@@ -177,71 +177,70 @@ static const int64_t kMaxCheckinRetryIntervalInSeconds = 1 << 5;
     _isCheckinInProgress = YES;
   }
   [self.checkinService
-      checkinWithExistingCheckin:self.checkinPreferences
-                      completion:^(FIRMessagingCheckinPreferences *checkinPreferences,
-                                   NSError *error) {
-                        @synchronized(self) {
-                          self->_isCheckinInProgress = NO;
-                        }
-                        if (error) {
-                          FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAuthService003,
-                                                  @"Failed to checkin device %@", error);
-                          [self notifyCheckinHandlersWithCheckin:nil error:error];
-                          return;
-                        }
-
-                        FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAuthService004,
-                                                @"Successfully got checkin credentials");
-                        BOOL hasSameCachedPreferences =
-                            [self cachedCheckinMatchesCheckin:checkinPreferences];
-                        checkinPreferences.hasPreCachedAuthCredentials = hasSameCachedPreferences;
-
-                        // Update to the most recent checkin preferences
-                        self.checkinPreferences = checkinPreferences;
-
-                        // Save the checkin info to disk
-                        // Keychain might not be accessible, so confirm that checkin preferences can
-                        // be saved
-                        [self->_checkinStore
-                            saveCheckinPreferences:checkinPreferences
-                                           handler:^(NSError *checkinSaveError) {
-                                             if (checkinSaveError && !hasSameCachedPreferences) {
-                                               // The checkin info was new, but it couldn't be
-                                               // written to the Keychain. Delete any stuff that was
-                                               // cached in memory. This doesn't delete any
-                                               // previously persisted preferences.
-                                               FIRMessagingLoggerError(
-                                                   kFIRMessagingMessageCodeService004,
-                                                   @"Unable to save checkin info, resetting "
-                                                   @"checkin preferences "
-                                                    "in memory.");
-                                               [checkinPreferences reset];
-                                               [self
-                                                   notifyCheckinHandlersWithCheckin:nil
-                                                                              error:
-                                                                                  checkinSaveError];
-                                             } else {
-                                               // The checkin is either new, or it was the same (and
-                                               // it couldn't be saved). Either way, report that the
-                                               // checkin preferences were received successfully.
-                                               [self notifyCheckinHandlersWithCheckin:
-                                                         checkinPreferences
-                                                                                error:nil];
-                                               if (!hasSameCachedPreferences) {
-                                                 // Checkin is new.
-                                                 // Notify any listeners that might be waiting for
-                                                 // checkin to be fetched, such as Firebase
-                                                 // Messaging (for its MCS connection).
-                                                 dispatch_async(dispatch_get_main_queue(), ^{
-                                                   [[NSNotificationCenter defaultCenter]
-                                                       postNotificationName:
-                                                           kFIRMessagingCheckinFetchedNotification
-                                                                     object:nil];
-                                                 });
-                                               }
+    checkinWithExistingCheckin:self.checkinPreferences
+                    completion:^(FIRMessagingCheckinPreferences *checkinPreferences,
+                                 NSError *error) {
+                      @synchronized(self) {
+                        self->_isCheckinInProgress = NO;
+                      }
+                      if (error) {
+                        FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAuthService003,
+                                                @"Failed to checkin device %@", error);
+                        [self notifyCheckinHandlersWithCheckin:nil error:error];
+                        return;
+                      }
+
+                      FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAuthService004,
+                                              @"Successfully got checkin credentials");
+                      BOOL hasSameCachedPreferences =
+                          [self cachedCheckinMatchesCheckin:checkinPreferences];
+                      checkinPreferences.hasPreCachedAuthCredentials = hasSameCachedPreferences;
+
+                      // Update to the most recent checkin preferences
+                      self.checkinPreferences = checkinPreferences;
+
+                      // Save the checkin info to disk
+                      // Keychain might not be accessible, so confirm that checkin preferences can
+                      // be saved
+                      [self->_checkinStore
+                          saveCheckinPreferences:checkinPreferences
+                                         handler:^(NSError *checkinSaveError) {
+                                           if (checkinSaveError && !hasSameCachedPreferences) {
+                                             // The checkin info was new, but it couldn't be
+                                             // written to the Keychain. Delete any stuff that was
+                                             // cached in memory. This doesn't delete any
+                                             // previously persisted preferences.
+                                             FIRMessagingLoggerError(
+                                                 kFIRMessagingMessageCodeService004,
+                                                 @"Unable to save checkin info, resetting "
+                                                 @"checkin preferences "
+                                                  "in memory.");
+                                             [checkinPreferences reset];
+                                             [self
+                                                 notifyCheckinHandlersWithCheckin:nil
+                                                                            error:checkinSaveError];
+                                           } else {
+                                             // The checkin is either new, or it was the same (and
+                                             // it couldn't be saved). Either way, report that the
+                                             // checkin preferences were received successfully.
+                                             [self
+                                                 notifyCheckinHandlersWithCheckin:checkinPreferences
+                                                                            error:nil];
+                                             if (!hasSameCachedPreferences) {
+                                               // Checkin is new.
+                                               // Notify any listeners that might be waiting for
+                                               // checkin to be fetched, such as Firebase
+                                               // Messaging (for its MCS connection).
+                                               dispatch_async(dispatch_get_main_queue(), ^{
+                                                 [[NSNotificationCenter defaultCenter]
+                                                     postNotificationName:
+                                                         kFIRMessagingCheckinFetchedNotification
+                                                                   object:nil];
+                                               });
                                              }
-                                           }];
-                      }];
+                                           }
+                                         }];
+                    }];
 }
 
 - (FIRMessagingCheckinPreferences *)checkinPreferences {

FirebasePerformance/Tests/Unit/Instruments/FPRNSURLSessionInstrumentTest.m

@@ -227,13 +227,13 @@
 - (void)testProxyWrappedSessionWithConfiguration {
   Method method = class_getClassMethod([NSURLSession class], @selector(sessionWithConfiguration:));
   IMP originalImp = method_getImplementation(method);
-  IMP swizzledImp = imp_implementationWithBlock(^(id session,
-                                                  NSURLSessionConfiguration *configuration) {
-    typedef NSURLSession *(*OriginalImp)(id, SEL, NSURLSessionConfiguration *);
-    NSURLSession *originalSession =
-        ((OriginalImp)originalImp)(session, @selector(sessionWithConfiguration:), configuration);
-    return [[FPRNSURLSessionProxy alloc] initWithSession:originalSession];
-  });
+  IMP swizzledImp =
+      imp_implementationWithBlock(^(id session, NSURLSessionConfiguration *configuration) {
+        typedef NSURLSession *(*OriginalImp)(id, SEL, NSURLSessionConfiguration *);
+        NSURLSession *originalSession = ((OriginalImp)originalImp)(
+            session, @selector(sessionWithConfiguration:), configuration);
+        return [[FPRNSURLSessionProxy alloc] initWithSession:originalSession];
+      });
   method_setImplementation(method, swizzledImp);
   NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
   XCTAssertEqual([[NSURLSession sessionWithConfiguration:config] class],

FirebaseRemoteConfig/Sources/RCNConfigFetch.m

@@ -244,46 +244,46 @@ static const NSInteger sFIRErrorCodeConfigFailed = -114;
     }
 
     // We have a valid token. Get the backing installationID.
-    [installations installationIDWithCompletion:^(NSString *_Nullable identifier,
-                                                  NSError *_Nullable error) {
-      RCNConfigFetch *strongSelf = weakSelf;
-      if (strongSelf == nil) {
-        return;
-      }
-
-      // Dispatch to the RC serial queue to update settings on the queue.
-      dispatch_async(strongSelf->_lockQueue, ^{
-        RCNConfigFetch *strongSelfQueue = weakSelf;
-        if (strongSelfQueue == nil) {
+    [installations
+      installationIDWithCompletion:^(NSString *_Nullable identifier, NSError *_Nullable error) {
+        RCNConfigFetch *strongSelf = weakSelf;
+        if (strongSelf == nil) {
           return;
         }
 
-        // Update config settings with the IID and token.
-        strongSelfQueue->_settings.configInstallationsToken = tokenResult.authToken;
-        strongSelfQueue->_settings.configInstallationsIdentifier = identifier;
-
-        if (!identifier || error) {
-          NSString *errorDescription =
-              [NSString stringWithFormat:@"Error getting iid : %@.", error];
-          FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000055", @"%@",
-                      [NSString stringWithFormat:@"%@", errorDescription]);
-          strongSelfQueue->_settings.isFetchInProgress = NO;
-          return [strongSelfQueue
-              reportCompletionOnHandler:completionHandler
-                             withStatus:FIRRemoteConfigFetchStatusFailure
-                              withError:[NSError
-                                            errorWithDomain:FIRRemoteConfigErrorDomain
-                                                       code:FIRRemoteConfigErrorInternalError
-                                                   userInfo:@{
-                                                     NSLocalizedDescriptionKey : errorDescription
-                                                   }]];
-        }
+        // Dispatch to the RC serial queue to update settings on the queue.
+        dispatch_async(strongSelf->_lockQueue, ^{
+          RCNConfigFetch *strongSelfQueue = weakSelf;
+          if (strongSelfQueue == nil) {
+            return;
+          }
+
+          // Update config settings with the IID and token.
+          strongSelfQueue->_settings.configInstallationsToken = tokenResult.authToken;
+          strongSelfQueue->_settings.configInstallationsIdentifier = identifier;
+
+          if (!identifier || error) {
+            NSString *errorDescription =
+                [NSString stringWithFormat:@"Error getting iid : %@.", error];
+            FIRLogError(kFIRLoggerRemoteConfig, @"I-RCN000055", @"%@",
+                        [NSString stringWithFormat:@"%@", errorDescription]);
+            strongSelfQueue->_settings.isFetchInProgress = NO;
+            return [strongSelfQueue
+                reportCompletionOnHandler:completionHandler
+                               withStatus:FIRRemoteConfigFetchStatusFailure
+                                withError:[NSError
+                                              errorWithDomain:FIRRemoteConfigErrorDomain
+                                                         code:FIRRemoteConfigErrorInternalError
+                                                     userInfo:@{
+                                                       NSLocalizedDescriptionKey : errorDescription
+                                                     }]];
+          }
 
-        FIRLogInfo(kFIRLoggerRemoteConfig, @"I-RCN000022", @"Success to get iid : %@.",
-                   strongSelfQueue->_settings.configInstallationsIdentifier);
-        [strongSelf doFetchCall:completionHandler];
-      });
-    }];
+          FIRLogInfo(kFIRLoggerRemoteConfig, @"I-RCN000022", @"Success to get iid : %@.",
+                     strongSelfQueue->_settings.configInstallationsIdentifier);
+          [strongSelf doFetchCall:completionHandler];
+        });
+      }];
   };
 
   FIRLogDebug(kFIRLoggerRemoteConfig, @"I-RCN000039", @"Starting requesting token.");

FirebaseRemoteConfig/Tests/Sample/RemoteConfigSampleApp/ViewController.m

@@ -126,8 +126,8 @@ static NSString *const FIRSecondFIRAppName = @"secondFIRApp";
       return;
     }
     [[FRCLog sharedInstance]
-        logToConsole:[NSString stringWithFormat:@"Fetch completed. Status=%@",
-                                                [strongSelf statusString:status]]];
+      logToConsole:[NSString stringWithFormat:@"Fetch completed. Status=%@",
+                                              [strongSelf statusString:status]]];
     if (error) {
       [[FRCLog sharedInstance] logToConsole:[NSString stringWithFormat:@"Fetch Error=%@", error]];
     }
@@ -281,8 +281,8 @@ static NSString *const FIRSecondFIRAppName = @"secondFIRApp";
       showText = @"config defaults";
     }
     [[FRCLog sharedInstance]
-        logToConsole:[NSString stringWithFormat:@"New %@ added %@ : %@\n", showText,
-                                                self.keyLabel.text, self.valueLabel.text]];
+      logToConsole:[NSString stringWithFormat:@"New %@ added %@ : %@\n", showText,
+                                              self.keyLabel.text, self.valueLabel.text]];
 
     self.keyLabel.text = @"";
     self.valueLabel.text = @"";

FirebaseStorage/Sources/FIRStorageObservableTask.m

@@ -204,12 +204,12 @@
     handlersCopy = [handlers copy];
   }  // @synchronized(self)
   [handlersCopy
-      enumerateKeysAndObjectsUsingBlock:^(
-          NSString *_Nonnull key, FIRStorageVoidSnapshot _Nonnull handler, BOOL *_Nonnull stop) {
-        dispatch_async(callbackQueue, ^{
-          handler(snapshot);
-        });
-      }];
+    enumerateKeysAndObjectsUsingBlock:^(
+        NSString *_Nonnull key, FIRStorageVoidSnapshot _Nonnull handler, BOOL *_Nonnull stop) {
+      dispatch_async(callbackQueue, ^{
+        handler(snapshot);
+      });
+    }];
 }
 
 @end