Minor clean up
fix 4 byte characters in UTF8UrlEncoder
Merge pull request #357 from chadselph/fix-utf8

Fix utf8 URL encoding
Force encoding when using String.toLower/UpperCase, close #361
Provided ability to use JDK ProxySelector

Fixes #360.

* Adds a useProxySelector option that tells async-http-client to use the
  JDK default ProxySelector.
* Adds a ProxyServerSelector interface that AsyncHttpClientConfig and
  ProxyUtils now use.
Merge pull request #365 from typesafehub/proxy-selector-1.7.x

Backported #362 to 1.7.x branch
- Changes for #368.
- Bump to Grizzly 2.3.5.
Didn't mean to commit target/source changes.
Set async queue writer "size" to AUTO_SIZE by default.
Reduce sleep to 4 seconds.  Verisign is sending a Keep-Alive header with a timeout of 5 seconds.  Can lead to the test failing indeterminately when the sleep was 5 seconds.
Call setMaxPendingBytesPerConnection() at the right time.
Use getHostName instead of getHostString for JDK5 compat
Properly initialize AsyncHttpClientConfigBean.ioThreadMultiplier

Otherwise, Netty provider will crash as worker count will be 0
Standalone test shouldn't target http://foo.com
Improvements to the FeedableBodyGenerator (Grizzly's).
 - Don't allow queueing of data before initiateAsyncTransfer has been invoked.  In low memory
    heaps, this could lead to an OOM if the source is feeding too fast.  The new behavior is to
    block until initiateAsyncTransfer is called, at which time the blocked thread may proceed with
    the feed operation.
 - Introduce the concept of a Feeder.  Implementations are responsible, at a high level, for:
       + letting the provider know that data is available to be fed without blocking
       + allowing the registration of a callback that the Feeder implementation may invoke
          to signal that more data is available, if it wasn't available at a previous point in time.
 - When using a Feeder with a secure request, the SSL handshake will be kicked off by the
    initiateAsyncTransfer call, but feeding of data will not occur until the handshake is complete.
    This is necessary as the SSLFilter will queue up all writes until the handshake is complete,
    and currently, the buffer isn't tied in with the transport flow control mechanism.
    NOTE:  This new SSL behavior is not currently applied when invoking the feed() method
    outside the context of a Feeder.  Still need to address that.
  - Exposed configuration of the async write queue limit through the FeedableBodyGenerator.
     This is an improvement on using a TransportCustomizer as any configuration there is
     transport-wide, and therefor applied to all Connections.  By exposing it here, each feeder
     may have a different byte limit.
 - Improved documentation for this class
Missed print.
Another round of refactoring of the FeedableBodyGenerator based on Feedback on the Grizzly user list.

 - Removed FeedableBodyGenerator.feed().  This method is now defined by the Feeder interface and implemented by the BaseFeeder abstract class.
 - The original Feeder is no called NonBlockingFeeder.
 - Added SimpleFeeder that is a simple callback notifying the implementation that asyncronous
    transferring has been initiated.  This allows for feeding in the same fashion as the
    original FeedableBodyGenerator implementation, but doesn't suffer from some of the
    drawbacks (like unbound feeding before transferring has started or causing an OOM due
    to feeding large amounts of data while performing an SSL handshake.
Adjust when flag is set.
Fix invalid string ref.
Deal with the case when the connection is cached.