Code review comment: I think it's  a good suggestion. Done.

Code before review:
public CheckpointableKeyedStateBackend<K> getRestoredKeyedStateBackend() {
return new AbstractKeyedStateBackend<K>(keyedStateBackend) {
@Override
public void setCurrentKey(K newKey) {
keyedStateBackend.setCurrentKey(newKey);
}
@Override
public void notifyCheckpointComplete(long checkpointId) throws Exception {
keyedStateBackend.notifyCheckpointComplete(checkpointId);
}
@Nonnull
@Override
public SavepointResources<K> savepoint() throws Exception {
return keyedStateBackend.savepoint();
}
@Override
public int numKeyValueStateEntries() {
return keyedStateBackend.numKeyValueStateEntries();
}
@Override
public <N> Stream<K> getKeys(String state, N namespace) {
return keyedStateBackend.getKeys(state, namespace);
}
@Override
public <N> Stream<Tuple2<K, N>> getKeysAndNamespaces(String state) {
return keyedStateBackend.getKeysAndNamespaces(state);
}
@Nonnull
@Override
public <N, SV, SEV, S extends State, IS extends S> IS createInternalState(
@Nonnull TypeSerializer<N> namespaceSerializer,
@Nonnull StateDescriptor<S, SV> stateDesc,
@Nonnull
StateSnapshotTransformer.StateSnapshotTransformFactory<SEV>
snapshotTransformFactory)
throws Exception {
return keyedStateBackend.createInternalState(
namespaceSerializer, stateDesc, snapshotTransformFactory);
}
@Override
public <N, S extends State> S getPartitionedState(
N namespace,
TypeSerializer<N> namespaceSerializer,
StateDescriptor<S, ?> stateDescriptor)
throws Exception {
S partitionedState =
keyedStateBackend.getPartitionedState(
namespace, namespaceSerializer, stateDescriptor);
functionDelegationHelper.addOrUpdate(stateDescriptor);
return partitionedState;
}
@Override
public <N, S extends State, V> S getOrCreateKeyedState(
TypeSerializer<N> namespaceSerializer, StateDescriptor<S, V> stateDescriptor)
throws Exception {
S keyedState =
keyedStateBackend.getOrCreateKeyedState(
namespaceSerializer, stateDescriptor);
functionDelegationHelper.addOrUpdate(stateDescriptor);
return keyedState;
}
@Nonnull
@Override
@SuppressWarnings("unchecked")
public <T extends HeapPriorityQueueElement & PriorityComparable<? super T> & Keyed<?>>
KeyGroupedInternalPriorityQueue<T> create(
@Nonnull String stateName,
@Nonnull TypeSerializer<T> byteOrderedElementSerializer) {
ChangelogKeyGroupedPriorityQueue<T> existingState =
(ChangelogKeyGroupedPriorityQueue<T>)
changelogStateFactory.getExistingState(
stateName,
StateMetaInfoSnapshot.BackendStateType.PRIORITY_QUEUE);
return existingState == null
? keyedStateBackend.create(stateName, byteOrderedElementSerializer)
: existingState;
}
@Nonnull
@Override
public RunnableFuture<SnapshotResult<KeyedStateHandle>> snapshot(
long checkpointId,
long timestamp,
@Nonnull CheckpointStreamFactory streamFactory,
@Nonnull CheckpointOptions checkpointOptions)
throws Exception {
return keyedStateBackend.snapshot(
checkpointId, timestamp, streamFactory, checkpointOptions);
}
@Override
public void dispose() {
super.dispose();
changelogStateFactory.dispose();
}
};
}

Line under review: @Nonnull TypeSerializer<T> byteOrderedElementSerializer) {

Code after addressing the review:
public CheckpointableKeyedStateBackend<K> getRestoredKeyedStateBackend() {
return wrapKeyedStateBackend(
keyedStateBackend, changelogStateFactory, functionDelegationHelper);
}