Unfortunately, I have no supporting document. I followed some advice given to me by rsandell. The purpose was the following: let's say you have two projects, libraryA and binaryB. binaryB uses library A. Both are linked to the same Gerrit project, and trigger on different conditions (e.g., different file paths). If a Patchset triggers only libraryA or binaryB, then there is no issue. But sometimes, a Patchset will modify something in libraryA and binaryB (an interface signature may change, whatever). In that case, it is important that binaryB wait for libraryA to be built before building. This is what is intended with this approach. We check for dependencies, and only allow a build to continue once all dependencies have been built. I currently depend on AbstractProject for determining what the dependencies are, and their status, and in particular, I need to check inside the buildmemory of gerrit to see if an event has triggered specific projects, and the current implementation of said memory is highly dependent on AbstractProject.
As I said, I could change the code in this pull request to depend as little as possible on AbstractProject, but this will not be 100%, because of the memory thing.

There are currently 3 approaches for checking on an event:
- for "normal" PatchsetCreated events, we assume that all projects are triggered for an event BEFORE any is passed through the TaskDipatcher. This happens to be true because there is a large quiet period. This assumption is unfortunately needed as there currently is no way to know when a PatchsetCreated event has finished "scanning" (it is not a EventLifecycle). 
- For a "retrigger.all" action, there is a specific place in the GerritTrigger code which allows to know when the "scanning" is over (method retriggerAllBuilds), so we have a "barrier" approach, which uses the TaskDispatcher's onTriggeringAll() and onDoneTriggeringAll() methods to prevent any builds with dependencies to start until all have been retriggered.
- For a retrigger done via the "Query Patchset" menu, the ManualPatchsetCreated event is used, which is an EventLifecycle. That allows us to first block builds with dependencies (onTriggeringAll), listen to the lifecycle events and in particular the triggerScanDone which calls the onDoneTriggeringAll() method and unblocks the barrier.

One we know, for all of these 3 cases, that the build and its possible dependencies have been triggered, we check in the build memory to see if a project's dependencies are completed, and we block until they are. That's about all there is to it :)