Isolate llcorehttp initialization into a utility class (LLAppCoreHttp)
that provides glue between app and library (sets up policies, handles
notifications).  Introduce 'TextureFetchConcurrency' debug setting to
provide some field control when absolutely necessary.

Move releaseHttpWaiters() to commonUpdate from doWork.
More appropriate home for it.  Have deleteOK() defer deletion
of anything in WAIT_HTTP_RESOURCE2 state to keep pointers valid
for the releaseHttpWaiters() method.  It will then transition
canceled operations to SEND_HTTP_REQ where they can be deleted.

Define expectations for headers for GET, POST, PUT requests.
Document those in the interface, test those with integration tests.
Verify that header overrides work as expected.

When releasing HTTP waiters, avoid unnecessary sort activity.
For Content-Type in responses, let libcurl do the work and removed
my parsing of headers.  Drop Content-Encoding as libcurl will deal
with that.  If anyone is interested, they can parse.

First round of integration tests.  Added a request header 'reflector'
to the web server to sent the client's headers back with a 'X-Reflect-'
prefix.  Use boost::regex to check various headers.  Run a test on
a simple GET and a byte-ranged GET a la texture fetch.

Using http_texture_load as the test subject, library looks clean.  Did
some better shutdown in the program itself and it looks better.  Libcurl
itself is making a lot of noise.  Adapted testrunner to run valgrind as
well but the memory allocation tester in the tools themselves grossly
interferes with Valgrind operations.

HttpResponse object now has two strings for these content headers.
Either or both may be empty.  Tidied up the cross-platform string
code and got more defensive about the length of a header line.
Integration test for the new response object.

Well, achieved that by doing work in bulk when needed.  But
turned into some additional things.  Change timebase from
mS to uS as, well, things are headed that way.  Implement
an HttpReplyQueue::fetchAll method (advertised one, hadn't
implemented it).

A 416 will just mean there's no more data and whatever we have
is complete.

Tweaked the boost source as per Boost issue #6185 using 1.49.0 sources
and this picks up the new build.  Debug viewer builds and runs.

Doesn't use sets or maps and so there's no ordering assumption to
be violated when priorities are changed.  Should also be faster.
Still want to get rid of the ancillary list, however...

30-second hang doesn't break subsequent tests.  Did this by
introducing threads into the HTTP server as I can't find the magic
to detect that my client has gone away.

First, try to issue ranged GETs that are always at least partially
satisfiable.  This will keep Varnish-type caches from simply sending
back 200/full asset responses to unsatisfiable requests.  Implement
awareness of Content-Range headers as well.  Currently they're not
coming back but they will be someday.

Also added some comments and changed the callback userdata argument
to be an HttpOpRequest rather than a libcurl handle.  Less code,
less clutter.

sort things out or use policy classes (eventually) to arrange low
and high priority traffic.  Subjectively, I think this works better
in practice (as I haven't implemented a dynamic priority setter yet).

Think I have found the major factor that causes the Linksys WRT54G V5 to
fall over in testing scenarios:  DNS.  For some historical reason, we're
trying to use libcurl without any DNS caching.  My implementation echoed
that and implemented it correctly and I was seeing a DNS request per request
on the wire.  The existing implementation tries to do that and has bugs
because it is clearing caching DNS data querying only once every few
seconds.  Once I started emulating the bug, comms through the WRT became
much, much more reliable.

Data problems after connections are established should be retried as well.
Extend to appropriate libcurl codes.  Also allow our connectivity to drop
to as low as a single connection when trying to recover.

The fetch state machine received a new timeout during the WAIT_HTTP_REQ
state.  For the integration, rather than jump the state to done, we issue
a request cancel and let the notification plumbing do the rest without
any race conditions or special-case logic.

Big delta was converting the new texture debugger support code
to the new library.  Viewer manifest should probably get an eyeball
before release.

SH-3184/SH-3221  More work on cleanup with better unit test work and more aggressive shutdown of a thread.
Some additional work let me enable a memory check for the clean shutdown case and
generally do a better job on other interfaces.  Request queue waiters now awake
on shutdown and don't sleep once the queue is turned off.  Much better semantically
for how this will be used.

With this commit, the cleanup paths should be production quality.  Unit tests have been
expanded to include cases requiring thread termination and cleanup by the worker thread.
Special operation/request added to support the unit tests.  Thread interface expanded
to include a very aggressive cancel() method that does not do cleanup but prevents the
thread from accessing objects that will be destroyed.

Groundwork is used for the default class which currently represents
texture fetching.  Class options implemented from API user into
HttpLibcurl.  Policy layer is going to start doing some traffic
shaping like work to solve problems with consumer-grade gear.
Need to have dynamic aspects to policies and that starts now...

Seems to be working correctly.  Not certain this is the fastest possible way
to provide a std::streambuf interface but it's visually acceptable.

Initial version that should have enough of the plumbing to produce
a working adapter.  Memory test is showing 8 bytes held after one
of the tests so I'm going to revisit that later.  But basic
functionality is there going by the unit tests.

Only thing interesting in this changeset is the discovery that a sleep
in the fake HTTP server ties up tests.  Need to thread that or fail on
client disconnect or something to speed that up and make it usable for
bigger test scenarios.  But good enough for now...

When a Content-Range header is received, make available the full triplet of <offset, length, fulllength>.

Pretty straightforward.  Still don't like how I'm managing
the options block.  Struct?  Accessors?  Can't decide.  But
the options now speed up the unit test runs even as I add
tests.

With much trial-and-error, cleaned up the banner on the texture console and made everything
mostly fit.  Added global cache read, cache write and resource wait count events to the
console display to show if cache is working.  On clean exit, emit a log line to report
stats to log file (intended for automated tests, maybe):
LLTextureFetch::endThread: CacheReads:  2618, CacheWrites:  117, ResWaits:  0, TotalHTTPReq:  117