Unfortunately, I'm not convinced. I really think we need to enforce atomicity of operations on the ``cache``. For instance, what happens if you have the following chaining of events:

1) ``findInBackground`` is called and the cache is filled with all subtypes. Now, the call to refreshing the view is executed, but the request isn't yet carried out by the UI thread.
2) ``dispose`` is called. The cache is being emptied.
3) The UI Thread finally executes (concurrently with the ``dispose`` call).

What is it going to be displayed?

Also, I just checked the JavaDoc of ``dispose``

``` 
/**
  * Disposes of this content provider.  
  * This is called by the viewer when it is disposed.
  * <p>
  * The viewer should not be updated during this call, as it is in the process
  * of being disposed.
  * </p>
  */
public void dispose();
```

So, you should also make sure that the chaining I described above isn't possible. But handling that case isn't enough, the ``cache`` is also cleaned in method ``inputChanged``, so a similar faulty behavior as the one I described could happen.