Multiple iterations of AES for key derivation? The keepass password manager uses multiple rounds of AES for its key derivation, as described here.  I was somewhat surprised that it wasn't using pbkdf2, bcrypt, or something more common.  Essentially, the key derivation is:

key = sha256(password)
cipher = AES(random_seed1, ECB)
for i in number_of_iterations:
  key = cipher.encrypt(key)
key = sha256(key)
key = sha256(random_seed2 + key)


Is there a name for this kdf?  Are there other systems that use something similar?  I'm mostly interested in general background info on the above approach.  Are there any weaknesses in this approach?  It seems considerably simpler than pbkdf2 and bcrypt.
One of the advantages of schemes like scrypt and bcrypt is that they are designed to be "hard" to brute-force. That is, the actual guts of the algorithm are designed to continuously use something that is difficult for a specialized implementation to speed up. For example, scrypt is based on sequential memory-hard operations, which makes sequential memory access a bottleneck of the computation process (meaning that the CPU is idle waiting on memory for some of the time).

This scheme doesn't leverage such a problem, and I would further argue that it's choke-point is pragmatically easy to brute-force due to the prevalence of AES-NI. For an attacker with AES-NI, a scheme like this would possibly the easiest type of scheme to brute-force because the choke-point uses the fastest cryptographic algorithm the attacker has access to.