Method refreshTokenInMainThread

CesiumAsync/src/CesiumIonAssetAccessor.cpp:213–305

} // namespace

CesiumAsync::SharedFuture<CesiumIonAssetAccessor::UpdatedToken>
CesiumIonAssetAccessor::refreshTokenInMainThread(
    const CesiumAsync::AsyncSystem& asyncSystem,
    const std::string& currentAuthorizationHeaderValue,
    const std::string& currentAccessTokenQueryParameterValue) {
  if (this->_tokenRefreshInProgress) {
    if (!this->_tokenRefreshInProgress->isReady()) {
      // Still waiting for an in-progress token refresh.
      return *this->_tokenRefreshInProgress;
    }

    const UpdatedToken& refreshedToken = this->_tokenRefreshInProgress->wait();
    bool hasHeader = !currentAuthorizationHeaderValue.empty();
    bool hasParameter = !currentAccessTokenQueryParameterValue.empty();
    bool headerChanged = hasHeader && refreshedToken.authorizationHeader !=
                                          currentAuthorizationHeaderValue;
    bool parameterChanged =
        hasParameter &&
        refreshedToken.token != currentAccessTokenQueryParameterValue;
    if (headerChanged || parameterChanged) {
      // Only use this refreshed token if it's different from the one we're
      // currently using. Otherwise, fall through and get a new token.
      return *this->_tokenRefreshInProgress;
    }
  }

  SPDLOG_LOGGER_INFO(
      this->_pLogger,
      "Refreshing Cesium ion token for URL {}.",
      this->_assetEndpointUrl);

  this->_tokenRefreshInProgress =
      this->_pAggregatedAccessor
          ->get(
              asyncSystem,
              this->_assetEndpointUrl,
              this->_assetEndpointHeaders)
          .thenInMainThread([this, asyncSystem](
                                std::shared_ptr<CesiumAsync::IAssetRequest>&&
                                    pIonRequest) {
            if (!this->_maybeUpdatedTokenCallback) {
              // Owner is already destroyed.
              return asyncSystem.createResolvedFuture(UpdatedToken());
            }

            const CesiumAsync::IAssetResponse* pIonResponse =
                pIonRequest->response();

            if (!pIonResponse) {
              // Token refresh failed.
              SPDLOG_LOGGER_ERROR(
                  this->_pLogger,
                  "Request failed while attempting to refresh the Cesium "
                  "ion token.");
              return asyncSystem.createResolvedFuture(UpdatedToken());
            }

            uint16_t statusCode = pIonResponse->statusCode();