I didn't think of that.

Thinking out loud here for a bit, in future in Play a WebSocket will look like this:

    RequestHeader => Future[Either[Result, (Iteratee, Enumerator)]]

The left case of the either is for cases where you want to reject the websocket, you might do this because the user wasn't authenticated, so instead you send a result with a 403 status.  Currently Play doesn't allow this, but I think it's worthwhile now to think about how this should be designed to allow it.

I think it would make sense for the websocket actor to only handle the websocket stream, and have the decision about whether to reject the websocket or not made before that, does that make sense to you?  In which case, it might look like this:

```scala
WebSocketAction.actorOf { req =>
  Right(upstream => MyActor.props(upstream))
}
```

We would also provide an async equivalent that let you return a future, the above would be using the convenience method so you didn't have to wrap your code in `Future.successful`.  So, the signature would be:

    RequestHeader => Future[Either[Result, ActorRef => Props]]

Does that make sense to you?

Given that then, perhaps it would make sense to do this now:

    RequestHeader => Future[ActorRef => Props]

And then the non asynchronous helper version, when used in a simple case like we have, it would look like this:

WebSocket.actorOf { req => upstream => MyActor.props(upstream) }

How does that sound to you?